@fitlab-ai/agent-infra 0.11.12 → 0.11.13

package/lib/sandbox/control/client.ts

@@ -10,11 +10,9 @@ import {
   type SandboxControlRequest,
   type SandboxControlResponse,
   type SandboxAgentClientRequest,
-  type SandboxTaskCreateRequest,
-  type SandboxTaskFinalizationRequest
+  type SandboxTaskCreateRequest
 } from './protocol.ts';
 import { isAgentClientId } from '../../agent-clients/types.ts';
-import { normalizeAgentToken } from '../../agent-clients/tokens.ts';
 import { readSandboxControlPayload, readSandboxControlStatus } from './state.ts';
 import type { TaskCreateCandidateV1 } from '../../task/create.ts';
 import { accessSandboxTaskView, taskViewFromStatus, type TaskViewAccessEffect } from './task-view.ts';
@@ -25,7 +23,6 @@ import { loadConfig } from '../config.ts';
 import { recoverSandboxControlFromHost } from './host-recovery.ts';
 
 const SANDBOX_CONTROL_RESPONSE_SETTLE_MS = 250;
-const SANDBOX_TASK_FINALIZATION_RECOVERY_BUDGET_MS = 5 * 60_000;
 
 export class SandboxControlClientError extends Error {
   readonly detail: SandboxControlError;
@@ -114,7 +111,6 @@ function preflight(
 
 function taskViewEffectForRequest(request: SandboxControlRequest): TaskViewAccessEffect | null {
   if (request.family === 'task-lifecycle') return 'progress';
-  if (request.family === 'task-finalization') return 'recovery';
   return null;
 }
 
@@ -216,9 +212,6 @@ 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') {
-      clientError('SANDBOX_CONTROL_BRANCH_ONLY', 'branch-only sandboxes cannot finalize tasks', false);
-    }
   }
   const encoded = `${JSON.stringify(request)}\n`;
   if (Buffer.byteLength(encoded, 'utf8') > SANDBOX_CONTROL_MAX_BYTES) {
@@ -421,9 +414,12 @@ 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 === 'agent-client' || params.family === 'task-finalization') {
+  if (params.family === 'task-create' || params.family === 'agent-client') {
     clientError('SANDBOX_CONTROL_COMMAND_DENIED', `'${params.family}' requires a typed request`, false);
   }
+  if (params.args[1] === 'complete') {
+    clientError('SANDBOX_CONTROL_COMMAND_DENIED', 'complete must use task-finalization', false);
+  }
   const auth = authority(params);
   const issuedAt = Date.now();
   const request: SandboxControlRequest = {
@@ -463,75 +459,6 @@ export function requestSandboxAgentOperation(params: Readonly<{
   return exchangeSandboxControl(request, params);
 }
 
-export function requestSandboxTaskFinalization(params: Readonly<{
-  agent: string;
-  channelDir?: string;
-  statusDir?: string;
-  token?: string;
-  generation?: string;
-  timeoutMs?: number;
-  recoveryBudgetMs?: number;
-}>): SandboxControlResponse {
-  const agent = normalizeAgentToken(params.agent);
-  if (!agent) clientError('SANDBOX_CONTROL_REQUEST_INVALID', 'task-finalization agent is invalid', false);
-  const auth = authority(params);
-  const issuedAt = Date.now();
-  const id = randomUUID();
-  const request: SandboxTaskFinalizationRequest = {
-    version: 4,
-    id,
-    ...auth,
-    issuedAt,
-    expiresAt: issuedAt + SANDBOX_CONTROL_ADMISSION_WINDOW_MS,
-    family: 'task-finalization',
-    operation: 'complete',
-    agent,
-    args: []
-  };
-  let response: SandboxControlResponse;
-  try {
-    response = exchangeSandboxControl(request, params);
-  } catch (error) {
-    if (!(error instanceof SandboxControlClientError)
-      || error.detail.code !== 'SANDBOX_CONTROL_RESULT_UNKNOWN'
-      || !error.accepted || !error.requestId) throw error;
-    return recoverAcceptedTaskFinalization(error.requestId, params);
-  }
-  if (response.phase === 'rejected' && response.error?.code === 'SANDBOX_CONTROL_RESULT_UNKNOWN') {
-    return recoverAcceptedTaskFinalization(response.id, params);
-  }
-  return response;
-}
-
-export function recoverAcceptedTaskFinalization(
-  requestId: string,
-  params: Readonly<{ recoveryBudgetMs?: number }>,
-  recover: typeof recoverSandboxControl = recoverSandboxControl
-): SandboxControlResponse {
-  const deadline = Date.now() + (params.recoveryBudgetMs ?? SANDBOX_TASK_FINALIZATION_RECOVERY_BUDGET_MS);
-  while (Date.now() < deadline) {
-    const timeoutMs = Math.min(30_000, deadline - Date.now());
-    if (timeoutMs <= 0) break;
-    try {
-      const response = recover(requestId, { timeoutMs });
-      if (response.phase === 'rejected' && response.error?.code === 'SANDBOX_CONTROL_RESULT_UNKNOWN') continue;
-      return response;
-    } catch (error) {
-      if (error instanceof SandboxControlClientError
-        && error.detail.code === 'SANDBOX_CONTROL_RESULT_UNKNOWN'
-        && error.requestId === requestId) continue;
-      throw error;
-    }
-  }
-  clientError(
-    'SANDBOX_CONTROL_RESULT_UNKNOWN',
-    'accepted finalization request remained unknown after the automatic recovery budget; inspect the receipt and resume by request id',
-    false,
-    true,
-    requestId
-  );
-}
-
 export function requestSandboxTaskCreate(params: Readonly<{
   candidate: TaskCreateCandidateV1; channelDir?: string; statusDir?: string;
   token?: string; generation?: string; timeoutMs?: number;

package/lib/sandbox/control/executor.ts

@@ -10,8 +10,6 @@ import {
   taskCreateFailure,
   type TaskCreateResult
 } from '../../task/create-service.ts';
-import { applyTaskFinalization } from '../../task/finalization.ts';
-import { serializeTaskFinalizationEnvelope } from '../../task/finalization-envelope.ts';
 import {
   bindSandboxControlTask,
   validateSandboxControlRequest,
@@ -256,22 +254,6 @@ function taskCreateExecutionFailure(requestId: string, code: string, message: st
   }));
 }
 
-function finalizationResult(result: Awaited<ReturnType<typeof applyTaskFinalization>>): SandboxControlExecutionResult {
-  const payload = {
-    version: 1,
-    status: result.status,
-    changed: result.changed,
-    accepted: true,
-    result,
-    error: result.error
-  };
-  return {
-    exitCode: result.status === 'completed' ? 0 : result.status === 'blocked' ? 2 : 1,
-    stdout: `${JSON.stringify(payload)}\n`,
-    stderr: ''
-  };
-}
-
 type ExecuteRequestOptions = Readonly<{
   createTask?: typeof createTask;
   agentClientOperation?: AgentClientSandboxControlOperation;
@@ -301,26 +283,6 @@ async function executeRequestInner(
     validateAgentClientOperation(request, manifest);
     return executeAgentClientOperation(request, manifest, manifestPath, options.agentClientOperation);
   }
-  if (request.family === 'task-finalization') {
-    const parsed = parseTaskControlOperation(
-      'task-finalization', [manifest.taskId!, 'complete', '--agent', request.agent]
-    );
-    if (parsed.family !== 'task-finalization') throw new Error('SANDBOX_CONTROL_FINALIZATION_OPERATION_INVALID');
-    const operation = parsed;
-    const result = dispatchTaskControlOperation(
-      createSandboxExecutorExecutionContext({
-        repoRoot: manifest.repoRoot,
-        worktreeRoot: manifest.worktreeRoot,
-        runtimeDir: manifest.runtimeDir,
-        taskId: manifest.taskId!,
-        generation: manifest.generation,
-        manifestPath,
-        requestId: request.id
-      }),
-      operation
-    );
-    return finalizationResult(await result);
-  }
   const boundArgs = bindSandboxControlTask(request, manifest.taskId!);
   let operation: TaskControlOperation;
   try {
@@ -438,7 +400,7 @@ export async function runSandboxControlExecutor(requestPath: string, nonce: stri
       family: request.family,
       operation: operation && typeof operation === 'object' && 'family' in operation && operation.family === 'task-lifecycle'
         ? operation.request.intent
-        : request.family === 'task-finalization' || request.family === 'agent-client' ? request.operation : null,
+        : request.family === 'agent-client' ? request.operation : null,
       phase: 'started-committed',
       outcome: 'in-progress'
     });
@@ -454,20 +416,7 @@ export async function runSandboxControlExecutor(requestPath: string, nonce: stri
     });
     const detail = error instanceof Error ? error.message : String(error);
     const code = /^([A-Z][A-Z0-9_]+)/u.exec(detail)?.[1] ?? 'SANDBOX_CONTROL_EXECUTOR_FAILED';
-    result = request.family === 'task-finalization'
-      ? {
-        exitCode: 1,
-        stdout: serializeTaskFinalizationEnvelope({
-          status: code === 'SANDBOX_CONTROL_RESULT_UNKNOWN' ? 'unknown' : 'failed',
-          changed: code === 'SANDBOX_CONTROL_RESULT_UNKNOWN' ? null : false,
-          accepted: true,
-          requestId: request.id,
-          result: null,
-          error: { code, message: detail, retryable: false }
-        }),
-        stderr: ''
-      }
-      : request.family === 'task-create'
+    result = request.family === 'task-create'
         ? taskCreateExecutionFailure(request.id, code, detail)
         : lifecycleFailure(code, detail);
   }

package/lib/sandbox/control/lifecycle.ts

@@ -23,6 +23,7 @@ import {
   type SandboxResourceLock
 } from './native-file-lock.ts';
 import { isSandboxAuthorityEvidence } from '../engines/authority.ts';
+import { validateSandboxControlIdentity } from './identity-sentinel.ts';
 import {
   parseSandboxControlStatus,
   readExecution,
@@ -639,6 +640,51 @@ function markSandboxControlRootQuiescing(root: string): void {
   }
 }
 
+function readTaskCompletionManifest(
+  root: string,
+  binding: Readonly<{ taskId: string; generation: string; controlRootId: string; statusDir: string }>
+): SandboxControlManifest {
+  const manifest = readSandboxControlManifest(path.join(root, 'manifest.json'));
+  const identity = validateSandboxControlIdentity({
+    publicStatusDir: binding.statusDir,
+    root,
+    mode: manifest.mode,
+    taskId: manifest.taskId,
+    generation: manifest.generation,
+    controlRootId: manifest.controlRootId
+  });
+  if (identity.state !== 'valid' || manifest.mode !== 'task-bound'
+    || manifest.taskId !== binding.taskId || manifest.generation !== binding.generation
+    || manifest.controlRootId !== binding.controlRootId) {
+    throw new Error('SANDBOX_CONTROL_IDENTITY_MISMATCH');
+  }
+  return manifest;
+}
+
+export async function quiesceSandboxControlForTaskCompletion(
+  root: string,
+  binding: Readonly<{ taskId: string; generation: string; controlRootId: string; statusDir: string }>,
+  timeoutMs = DEFAULT_QUIESCE_TIMEOUT_MS
+): Promise<void> {
+  const resolvedRoot = path.resolve(root);
+  const manifest = readTaskCompletionManifest(resolvedRoot, binding);
+  markSandboxControlRootQuiescing(resolvedRoot);
+  const deadline = Date.now() + timeoutMs;
+  const startupPath = path.join(resolvedRoot, BROKER_STARTING_FILE);
+  const brokerPath = path.join(resolvedRoot, 'broker.json');
+  while (true) {
+    const startup = readStartupOwner(startupPath);
+    if (fs.existsSync(startupPath) && !startup) throw new Error('SANDBOX_CONTROL_BROKER_START_TRANSITION');
+    const broker = readBrokerOwner(brokerPath);
+    if (broker && (broker.token !== manifest.token || broker.generation !== manifest.generation)) {
+      throw new Error('SANDBOX_CONTROL_OWNER_MISMATCH');
+    }
+    if (!startup && !broker) return;
+    if (Date.now() >= deadline) throw new Error('SANDBOX_CONTROL_BROKER_DRAIN_TIMEOUT');
+    await new Promise((resolve) => setTimeout(resolve, 25));
+  }
+}
+
 function recordSandboxRemovalPending(
   root: string,
   manifest: SandboxControlManifest,
@@ -1108,12 +1154,29 @@ function readSandboxControlManifestValue(manifestPath: string): SandboxControlMa
     || (candidate.mode === 'branch-only' && candidate.taskId !== null)
     || !isSandboxAuthorityEvidence(candidate.authorityEvidence)) throw new Error('SANDBOX_CONTROL_MANIFEST_INVALID');
   const root = path.dirname(path.resolve(manifestPath));
-  if (path.resolve(candidate.channelDir) !== path.join(root, 'channel')
-    || path.resolve(candidate.publicStatusDir) !== path.join(root, 'public')
-    || path.resolve(candidate.processingDir) !== path.join(root, 'processing')) {
+  const canonicalRoot = fs.realpathSync.native(root);
+  const matchesControlChildPath = (candidatePath: string, name: string): boolean => {
+    const resolved = path.resolve(candidatePath);
+    if (path.basename(resolved) !== name) return false;
+    const expected = path.join(canonicalRoot, name);
+    try {
+      return fs.realpathSync.native(resolved) === expected;
+    } catch (error) {
+      if ((error as NodeJS.ErrnoException).code !== 'ENOENT') throw error;
+      try {
+        return fs.realpathSync.native(path.dirname(resolved)) === canonicalRoot;
+      } catch (parentError) {
+        if ((parentError as NodeJS.ErrnoException).code !== 'ENOENT') throw parentError;
+        return false;
+      }
+    }
+  };
+  if (!matchesControlChildPath(candidate.channelDir, 'channel')
+    || !matchesControlChildPath(candidate.publicStatusDir, 'public')
+    || !matchesControlChildPath(candidate.processingDir, 'processing')) {
     throw new Error('SANDBOX_CONTROL_MANIFEST_INVALID');
   }
-  if (path.resolve(candidate.runtimeDir) !== path.join(root, 'runtime')) {
+  if (!matchesControlChildPath(candidate.runtimeDir, 'runtime')) {
     throw new Error('SANDBOX_CONTROL_MANIFEST_INVALID');
   }
   const normalized: SandboxControlManifest = {

package/lib/sandbox/control/protocol.ts

@@ -1,6 +1,5 @@
 import { createHash } from 'node:crypto';
 import { validateTaskCreateCandidate, type TaskCreateCandidateV1 } from '../../task/create.ts';
-import { normalizeAgentToken } from '../../agent-clients/tokens.ts';
 import { isAgentClientId } from '../../agent-clients/types.ts';
 import type { ProcessIdentity } from '../../server/process-state.ts';
 import type { SandboxAuthorityEvidenceV1 } from '../engines/authority.ts';
@@ -15,7 +14,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-finalization', 'task-create', 'agent-client'] as const;
+export const SANDBOX_CONTROL_FAMILIES = ['task-lifecycle', 'task-create', 'agent-client'] as const;
 export type SandboxControlTimingPolicy = Readonly<{
   controlTickMs: number;
   parkedBindingInitialMs: number;
@@ -62,9 +61,6 @@ type RequestBase = Readonly<{
 export type SandboxTaskCommandRequest = RequestBase & Readonly<{
   family: 'task-lifecycle'; args: string[];
 }>;
-export type SandboxTaskFinalizationRequest = RequestBase & Readonly<{
-  family: 'task-finalization'; operation: 'complete'; agent: string; args: [];
-}>;
 export type SandboxTaskCreateRequest = RequestBase & Readonly<{
   family: 'task-create'; candidate: TaskCreateCandidateV1;
 }>;
@@ -74,7 +70,7 @@ export type SandboxAgentClientRequest = RequestBase & Readonly<{
   operation: string;
   payload: Record<string, unknown>;
 }>;
-export type SandboxControlRequest = SandboxTaskCommandRequest | SandboxTaskFinalizationRequest | SandboxTaskCreateRequest | SandboxAgentClientRequest;
+export type SandboxControlRequest = SandboxTaskCommandRequest | SandboxTaskCreateRequest | SandboxAgentClientRequest;
 export type SandboxControlError = Readonly<{ code: string; message: string; retryable: boolean }>;
 export type SandboxControlResultEvidence = Readonly<{
   version: 1;
@@ -270,24 +266,14 @@ export function validateSandboxControlRequest(
     }
     return request as SandboxAgentClientRequest;
   }
-  if (request.family === 'task-finalization') {
-    const expected = ['agent', 'args', 'expiresAt', 'family', 'generation', 'id', 'issuedAt', 'operation', 'token', 'version'];
-    if (Object.keys(request).sort().join(',') !== expected.sort().join(',')
-      || request.operation !== 'complete'
-      || !Array.isArray(request.args) || request.args.length !== 0
-      || typeof request.agent !== 'string' || normalizeAgentToken(request.agent) !== request.agent) {
-      fail('SANDBOX_CONTROL_REQUEST_INVALID', 'task-finalization request schema or authorization is invalid');
-    }
-    if (manifest.mode !== 'task-bound' || !manifest.taskId) {
-      fail('SANDBOX_CONTROL_BRANCH_ONLY', 'branch-only sandboxes cannot finalize tasks');
-    }
-    return request as SandboxTaskFinalizationRequest;
-  }
   const expected = ['args', '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 (request.args[1] === 'complete') {
+    fail('SANDBOX_CONTROL_COMMAND_DENIED', 'complete must use task-finalization');
+  }
   if (manifest.mode !== 'task-bound' || !manifest.taskId) {
     fail(
       'SANDBOX_CONTROL_BRANCH_ONLY',
@@ -298,7 +284,7 @@ export function validateSandboxControlRequest(
 }
 
 export function bindSandboxControlTask(request: SandboxControlRequest, taskId: string): string[] {
-  if (request.family === 'task-create' || request.family === 'agent-client' || request.family === 'task-finalization') {
+  if (request.family === 'task-create' || request.family === 'agent-client') {
     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');

package/lib/sandbox/control/server.ts

@@ -76,7 +76,6 @@ import { recoverAgentClientOperation, validateAgentClientOperation } from './age
 import { validateSandboxControlIdentity } from './identity-sentinel.ts';
 import {
   mergeSandboxTaskView,
-  taskViewAfterFinalization,
   taskViewForManifest,
   type SandboxTaskView
 } from './task-view.ts';
@@ -91,34 +90,6 @@ type ActiveExecution = {
   settled: boolean;
 };
 
-async function taskViewForFinalizationResult(
-  manifest: SandboxControlManifest,
-  request: SandboxControlRequest,
-  result: SandboxControlExecutionResult | null
-): Promise<SandboxTaskView | null> {
-  if (request.family !== 'task-finalization' || result?.exitCode !== 0 || !manifest.taskId) return null;
-  let receipt: unknown = null;
-  for (let attempt = 0; attempt < 100 && !receipt; attempt += 1) {
-    try {
-      receipt = readTaskFinalizationReceipt(manifest.repoRoot, manifest.taskId);
-    } catch {
-      // A missing or temporarily moving task directory is retried before publishing completion.
-    }
-    if (!receipt) await new Promise((resolve) => setTimeout(resolve, 10));
-  }
-  const finalized = taskViewAfterFinalization({
-    taskId: manifest.taskId,
-    generation: manifest.generation,
-    requestId: request.id,
-    receipt
-  });
-  if (finalized.state === 'unknown') return finalized;
-  const canonical = taskViewForManifest({ ...manifest, receipt });
-  return canonical.state === 'current' && canonical.observedSource === 'completed'
-    ? canonical
-    : finalized;
-}
-
 function appendBrokerAudit(
   manifest: SandboxControlManifest,
   event: string,
@@ -128,7 +99,6 @@ function appendBrokerAudit(
 }
 
 function operationKey(request: SandboxControlRequest): string | null {
-  if (request.family === 'task-finalization') return request.operation;
   if (request.family === 'task-create') return 'create';
   if (request.family === 'agent-client') return request.operation;
   if (request.family !== 'task-lifecycle') return null;
@@ -327,9 +297,7 @@ async function readRecoveryDomain(
   payloadOutput: string | null
 ): Promise<RecoveryDomainEvidence> {
   if (!operation) return { domain: null };
-  const taskRef = request.family === 'task-finalization'
-    ? manifest.taskId
-    : 'args' in request ? request.args[0] ?? null : manifest.taskId;
+  const taskRef = 'args' in request ? request.args[0] ?? null : manifest.taskId;
   const output = parseControlOutput(payloadOutput);
   if (!taskRef && operation.family !== 'task-create' && operation.family !== 'agent-client') {
     return { domain: null };
@@ -842,6 +810,7 @@ export async function serveSandboxControl(
   let bindingBackoffMs: number = timing.parkedBindingInitialMs;
   try {
     if (!brokerOwns()) return;
+    if (isSandboxControlRootQuiescing(root)) return;
     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,
@@ -932,11 +901,6 @@ export async function serveSandboxControl(
         settledExecution = active;
         active = null;
       }
-      const finalizationView = settledExecution
-        ? await taskViewForFinalizationResult(manifest, settledExecution.request, settledExecution.result)
-        : null;
-      if (finalizationView) taskView = finalizationView;
-
       let reasonCode: string | null = null;
       try {
         if (!brokerOwns()) break;
@@ -1005,7 +969,9 @@ export async function serveSandboxControl(
       }
 
       let retiring = false;
-      for (const name of fs.readdirSync(requestsDir).sort()) {
+      const quiescing = isSandboxControlRootQuiescing(root);
+      if (quiescing && !active) break;
+      if (!quiescing) for (const name of fs.readdirSync(requestsDir).sort()) {
         if (!/^[a-f0-9-]{16,64}\.json$/.test(name)) continue;
         const id = name.slice(0, -5);
         const source = path.join(requestsDir, name);
@@ -1013,6 +979,10 @@ export async function serveSandboxControl(
         let validatedRequest: SandboxControlRequest | null = null;
         let prepared: PreparedSandboxControlExecution | null = null;
         try {
+          if (isSandboxControlRootQuiescing(root)) {
+            retiring = true;
+            break;
+          }
           if (!brokerOwns()) {
             retiring = true;
             break;
@@ -1230,11 +1200,6 @@ export async function serveSandboxControl(
         }
       }
       if (owned && active.result && active.resultEvidenceWritten) {
-        const finalizationView = await taskViewForFinalizationResult(manifest, active.request, active.result);
-        if (finalizationView) {
-          taskView = finalizationView;
-          writeSandboxControlStatus(manifest, broker, 'healthy', null, null, Date.now(), taskView);
-        }
         if (publishExecutionResult(manifest, active.request, active.result, brokerOwns)) {
           if (brokerOwns()) {
             removeAcceptedResponse(manifest, active.request.id);

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

@@ -180,25 +180,6 @@ export function projectSandboxTaskView(input: TaskViewProjectionInput): SandboxT
   };
 }
 
-export function taskViewAfterFinalization(params: Readonly<{
-  taskId: string;
-  generation: string;
-  requestId: string;
-  receipt: unknown;
-}>): SandboxTaskView {
-  const receipt = receiptIdentity(params.receipt, params.generation, params.requestId);
-  if (!receipt) {
-    return {
-      state: 'unknown', taskId: params.taskId, observedSource: 'unknown', receipt: null,
-      reasonCode: 'SANDBOX_TASK_VIEW_RECEIPT_INVALID'
-    };
-  }
-  return {
-    state: 'finalized-stale', taskId: params.taskId, observedSource: 'active', receipt,
-    reasonCode: 'SANDBOX_TASK_VIEW_FINALIZED'
-  };
-}
-
 export function mergeSandboxTaskView(
   canonical: SandboxTaskView,
   previous: SandboxTaskView

package/lib/sandbox/mounts.ts

@@ -31,6 +31,7 @@ export function sandboxCoreBindMounts(
     worktreeGitFile?: string;
     runtimeDir?: string;
     taskSources?: string[];
+    completedTaskSource?: string;
     taskId?: string;
   }
 ): SandboxBindMountDeclaration[] {
@@ -77,6 +78,13 @@ export function sandboxCoreBindMounts(
       containerPath: taskMountPath,
       readOnly: false
     });
+    if (overrides.completedTaskSource) {
+      mounts.push({
+        hostPaths: [overrides.completedTaskSource],
+        containerPath: path.posix.join('/workspace/.agents/workspace/completed', overrides.taskId!),
+        readOnly: false
+      });
+    }
   }
   mounts.push(
     {

package/lib/sandbox/recovery.ts

@@ -25,6 +25,7 @@ import { sandboxCoreBindMounts } from './mounts.ts';
 import { resolveSandboxGitMetadata } from './git-metadata.ts';
 import {
   assertSandboxTaskSource,
+  sandboxCompletedTaskMountSource,
   sandboxControlPaths,
   sandboxWorkspaceViewPaths
 } from './workspace-view.ts';
@@ -673,31 +674,43 @@ export function startCompletedSandboxContainer(params: {
   const activeRoot = path.join(params.config.repoRoot, '.agents', 'workspace', 'active');
   const historicalSource = path.join(activeRoot, params.taskId);
   fs.mkdirSync(activeRoot, { recursive: true });
+  let replacedEmptyRoot = false;
+  let emptyRootMode = 0o700;
   try {
-    fs.lstatSync(historicalSource);
-    throw new Error(
-      `SANDBOX_COMPLETED_SOURCE_CONFLICT: historical task source already exists at ${historicalSource}`
-    );
+    const existing = fs.lstatSync(historicalSource);
+    if (existing.isSymbolicLink() || !existing.isDirectory() || fs.readdirSync(historicalSource).length > 0) {
+      throw new Error(
+        `SANDBOX_COMPLETED_SOURCE_CONFLICT: historical task source already exists at ${historicalSource}`
+      );
+    }
+    emptyRootMode = existing.mode & 0o777;
+    fs.rmdirSync(historicalSource);
+    replacedEmptyRoot = true;
   } catch (error) {
     if (!(error instanceof Error && 'code' in error && error.code === 'ENOENT')) throw error;
   }
 
-  fs.symlinkSync(
-    completedSource,
-    historicalSource,
-    process.platform === 'win32' ? 'junction' : 'dir'
-  );
+  let temporaryLink = false;
   try {
+    fs.symlinkSync(
+      completedSource,
+      historicalSource,
+      process.platform === 'win32' ? 'junction' : 'dir'
+    );
+    temporaryLink = true;
     params.start(params.engine, params.container);
   } finally {
-    const temporarySource = fs.lstatSync(historicalSource);
-    const resolvedSource = fs.realpathSync.native(historicalSource);
-    if (!temporarySource.isSymbolicLink() || resolvedSource !== completedSource) {
-      throw new Error(
-        `SANDBOX_COMPLETED_SOURCE_CHANGED: refusing to remove unexpected path at ${historicalSource}`
-      );
+    if (temporaryLink) {
+      const temporarySource = fs.lstatSync(historicalSource);
+      const resolvedSource = fs.realpathSync.native(historicalSource);
+      if (!temporarySource.isSymbolicLink() || resolvedSource !== completedSource) {
+        throw new Error(
+          `SANDBOX_COMPLETED_SOURCE_CHANGED: refusing to remove unexpected path at ${historicalSource}`
+        );
+      }
+      fs.unlinkSync(historicalSource);
     }
-    fs.unlinkSync(historicalSource);
+    if (replacedEmptyRoot) fs.mkdirSync(historicalSource, { mode: emptyRootMode });
   }
 }
 
@@ -749,6 +762,7 @@ function expectedMounts(params: {
     ? recoveryTaskSources(config.repoRoot, params.workspace.taskId)
     : null;
   const taskId = params.workspace.mode === 'task-bound' ? params.workspace.taskId : null;
+  const completedTaskSource = taskId ? sandboxCompletedTaskMountSource(config.repoRoot, taskId) : null;
   const worktrees = worktreeDirCandidates(config, branch).filter((candidate) =>
     fs.existsSync(path.join(candidate, '.git'))
   );
@@ -770,6 +784,7 @@ function expectedMounts(params: {
       : {
         runtimeDir: control.runtimeDir,
         taskSources: taskSources!.accessiblePaths,
+        completedTaskSource: completedTaskSource!,
         taskId: taskId!
       })
   }).map((mount) => ({
@@ -780,6 +795,10 @@ function expectedMounts(params: {
       && mount.containerPath === `/workspace/.agents/workspace/active/${taskId}`
       ? { sourceAccessiblePaths: taskSources!.accessiblePaths }
       : {}),
+    ...(completedTaskSource !== null && taskId !== null
+      && mount.containerPath === `/workspace/.agents/workspace/completed/${taskId}`
+      ? { sourceAccessiblePaths: [completedTaskSource] }
+      : {}),
     expectedRW: !mount.readOnly
   }));
   const live = tools.flatMap((tool) =>