V48 Gate 3 (implementation-only): #25 route dispatches deposit synthesis to the sandbox host in-box

Closes #25. The deposit route now branches on the configured HostKind: InlineHost runs the synthesis in this box (provision + pipeline in-process, unchanged); SandboxHost runs it IN the box via runDepositInBoxHarness — builds an asset-pack harness in deposit mode (git source + steering), dispatches it on VercelSandboxPipelineHost.runHarness (the pipeline executes in the box over its local checkout), and reads the synthesized options from evidence.depositOptions. Both branches then run the SAME pure projection (validateDepositSynthesisOptions + buildRealDepositAssetPackOptionSynthesis) and persist — identical result.

- runDepositInBoxHarness (deposit-source-provisioning.ts): builds the deposit harness + dispatches (injectable host for tests) + returns evidence.depositOptions.
- route: hostKind branch; the sandbox path rebuilds a minimal inventory from the returned options' covered paths (exclusions already enforced in-box) for the projection/persistence.

Tests: runDepositInBoxHarness (deposit-mode plan + steering + git source; empty evidence -> []); the route sandbox-branch test (dispatches in-box, pipeline+provision NOT called, persists the decision payload). Fixed a mock-isolation leak (reset queued .once() impls in beforeEach). uapi deposit suites 3/14 green; tsc clean.

Real-sandbox execution is verified against deployed sandbox infra; the dispatch + projection are unit-tested with a mocked host.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

Author: geraldarthurdavis

uapi/app/api/deposit/synthesize-options/route.ts

@@ -12,13 +12,16 @@ import {
   normalizeProtectedIpExclusions,
   validateDepositSynthesisOptions,
   type AssetPacksSynthesisResult,
+  type AssetPacksSynthesisSourceInventory,
 } from '@bitcode/pipeline-asset-pack/asset-packs-synthesis';
 import { synthesizeAssetPacksPipeline } from '@bitcode/pipeline-asset-pack';
 import { buildRealDepositAssetPackOptionSynthesis } from '@bitcode/pipeline-asset-pack/deposit-option-real-synthesis';
 import { isAssetPackRealInferenceEnabled } from '@bitcode/pipeline-asset-pack/runtime-inference-policy';
 import {
   provisionDepositSourceInventory,
   resolveDepositPipelineHost,
+  runDepositInBoxHarness,
+  selectDepositHostKind,
 } from '@/lib/deposit-source-provisioning';
 import {
   bitcodeServerTelemetry,
@@ -203,66 +206,101 @@ export async function POST(request: Request) {
       supabaseAdmin,
     );
     const reference = sourceCommit || sourceBranch || 'HEAD';
-    // Provision the FULL repository checkout on the primitive Host (InlineHost
-    // in-process; the Vercel Sandbox host in prod). The static-analysis measurement
-    // reads the real full source (inventory.sources); bounded samples feed the
-    // prompts. This is the host's job — the dispatching request does not clone.
-    const host = await resolveDepositPipelineHost();
-    await emitStatus(
-      `Provisioning ${repositoryFullName}@${reference} on the ${host.capabilities.hostKind} host…`,
-    );
-    const provisioned = await provisionDepositSourceInventory({
-      host,
-      repositoryFullName,
-      url: `https://github.com/${repositoryFullName}.git`,
-      revision: reference,
-      token: auth.accessToken,
-    });
-    const inventory = applyExclusionsToInventory(provisioned, protectedIpExclusions);
-    await emitStatus(
-      `Checkout ready: ${inventory.paths.length} files (${inventory.excludedPathCount} withheld by ${protectedIpExclusions.length} protected-IP exclusions; full source measured, ${inventory.samples.length} prompt excerpts).`,
-    );
-
     const DEPOSIT_OPTION_KINDS = ['capability-slice', 'implementation-pattern', 'proof-operations-slice'];
+    // The synthesis runs WITHIN the configured Host. InlineHost runs it in this box
+    // (provision the full checkout + run the pipeline in-process). SandboxHost runs it
+    // IN the box (#25): the harness dispatches the deposit pipeline into the sandbox,
+    // which clones + runs over its local checkout; the options come back in evidence.
+    const hostKind = selectDepositHostKind();
+    let rawOptions: Parameters<typeof validateDepositSynthesisOptions>[0];
+    let inventoryPaths: string[];
+    // The inventory the option projection + persistence reference. Real for inline;
+    // for the sandbox path the box held the inventory, so a minimal shape is rebuilt
+    // from the returned options (exclusions were already enforced in-box).
+    let inventory: AssetPacksSynthesisSourceInventory;
 
-    // The full SynthesizeAssetPacks SDIVF pipeline (deposit mode) is the ONLY deposit
-    // synthesis path: Setup → Discovery → Implementation → Validation → Finish,
-    // streaming the rich phase→agent→step→failsafe→generation telemetry. Validation
-    // runs the formal absolutes measurement — it is never skipped.
-    await emitStatus(
-      'Running SynthesizeAssetPacks (deposit mode): Setup → Discovery → Implementation → Validation → Finish…',
-    );
-    const [owner, name] = repositoryFullName.split('/');
-    await synthesizeAssetPacksPipeline(
-      {
-        mode: 'deposit',
-        synthesizeMode: 'deposit',
+    if (hostKind === 'sandbox') {
+      await emitStatus(
+        `Dispatching deposit synthesis to the sandbox host (in-box) for ${repositoryFullName}@${reference}…`,
+      );
+      rawOptions = (await runDepositInBoxHarness({
         repositoryFullName,
-        sourceBranch,
-        sourceCommit,
-        repository: {
-          owner,
-          name,
-          repo: name,
-          branch: sourceBranch,
-          commit: sourceCommit,
-          fullName: repositoryFullName,
-          url: `https://github.com/${repositoryFullName}`,
-        },
+        revision: reference,
+        branch: sourceBranch,
+        commit: sourceCommit,
+        token: auth.accessToken,
         obfuscations,
         protectedIpExclusions,
         demandContext,
-        inventory,
-        candidateKinds: DEPOSIT_OPTION_KINDS,
-      } as never,
-      execution as never,
-    );
-    const rawOptions = ((execution as any).get?.('implementation', 'options') ??
-      (execution as any).findUp?.('implementation', 'options') ??
-      []) as Parameters<typeof validateDepositSynthesisOptions>[0];
+        onEvent: (event) => {
+          void emitStatus(`sandbox: ${event.type}`);
+        },
+      })) as Parameters<typeof validateDepositSynthesisOptions>[0];
+      // The in-box run validated covered paths against the real inventory; the route's
+      // re-validation enforces exclusions over the options' own covered paths.
+      inventoryPaths = [
+        ...new Set((rawOptions || []).flatMap((option: any) => option?.coveredSourcePaths || [])),
+      ] as string[];
+      inventory = {
+        paths: inventoryPaths,
+        samples: [],
+        sources: [],
+        totalPathCount: inventoryPaths.length,
+        excludedPathCount: 0,
+      };
+    } else {
+      const host = await resolveDepositPipelineHost();
+      await emitStatus(
+        `Provisioning ${repositoryFullName}@${reference} on the ${host.capabilities.hostKind} host…`,
+      );
+      const provisioned = await provisionDepositSourceInventory({
+        host,
+        repositoryFullName,
+        url: `https://github.com/${repositoryFullName}.git`,
+        revision: reference,
+        token: auth.accessToken,
+      });
+      inventory = applyExclusionsToInventory(provisioned, protectedIpExclusions);
+      await emitStatus(
+        `Checkout ready: ${inventory.paths.length} files (${inventory.excludedPathCount} withheld by ${protectedIpExclusions.length} protected-IP exclusions; full source measured, ${inventory.samples.length} prompt excerpts).`,
+      );
+      await emitStatus(
+        'Running SynthesizeAssetPacks (deposit mode): Setup → Discovery → Implementation → Validation → Finish…',
+      );
+      const [owner, name] = repositoryFullName.split('/');
+      await synthesizeAssetPacksPipeline(
+        {
+          mode: 'deposit',
+          synthesizeMode: 'deposit',
+          repositoryFullName,
+          sourceBranch,
+          sourceCommit,
+          repository: {
+            owner,
+            name,
+            repo: name,
+            branch: sourceBranch,
+            commit: sourceCommit,
+            fullName: repositoryFullName,
+            url: `https://github.com/${repositoryFullName}`,
+          },
+          obfuscations,
+          protectedIpExclusions,
+          demandContext,
+          inventory,
+          candidateKinds: DEPOSIT_OPTION_KINDS,
+        } as never,
+        execution as never,
+      );
+      rawOptions = ((execution as any).get?.('implementation', 'options') ??
+        (execution as any).findUp?.('implementation', 'options') ??
+        []) as Parameters<typeof validateDepositSynthesisOptions>[0];
+      inventoryPaths = inventory.paths;
+    }
+
     const validated = validateDepositSynthesisOptions(rawOptions, {
       lens: 'deposit',
-      inventoryPaths: inventory.paths,
+      inventoryPaths,
       protectedIpExclusions,
       candidateKinds: DEPOSIT_OPTION_KINDS,
     });

uapi/lib/deposit-source-provisioning.ts

@@ -16,10 +16,15 @@
 
 import {
   InlineHost,
+  VercelSandboxPipelineHost,
+  buildAssetPackSandboxHarness,
+  loadVercelSandboxFactory,
   readWorkspaceSources,
   type BitcodeHostKind,
   type BitcodePipelineHost,
   type HostSourceFile,
+  type PipelineHarnessHostEvent,
+  type PipelineHarnessRunResult,
 } from '@bitcode/pipeline-hosts';
 
 export interface ProvisionedDepositInventory {
@@ -87,6 +92,65 @@ export async function resolveDepositPipelineHost(): Promise<BitcodePipelineHost>
   return new InlineHost();
 }
 
+/** A host that can run a harness plan (the VercelSandboxPipelineHost shape). */
+export interface DepositInBoxHarnessHost {
+  runHarness(plan: unknown): Promise<PipelineHarnessRunResult>;
+}
+
+/**
+ * Run the deposit synthesis IN the sandbox box (#25). Builds an asset-pack harness in
+ * DEPOSIT mode (git source for the revision + steering), dispatches it on the sandbox
+ * host (the pipeline runs in the box, reading its local checkout), and returns the
+ * synthesized options surfaced in the evidence (`depositOptions`). The host is
+ * injectable so the dispatch is unit-tested without a real sandbox.
+ */
+export async function runDepositInBoxHarness(input: {
+  repositoryFullName: string;
+  revision: string;
+  branch: string | null;
+  commit: string | null;
+  token?: string;
+  obfuscations: string | null;
+  protectedIpExclusions: string[];
+  demandContext: string[];
+  onEvent?: (event: PipelineHarnessHostEvent) => void;
+  hostFactory?: () => Promise<DepositInBoxHarnessHost>;
+}): Promise<unknown[]> {
+  const plan = buildAssetPackSandboxHarness({
+    mode: 'asset_pack_pipeline',
+    synthesizeMode: 'deposit',
+    read: { id: `deposit-read-${input.repositoryFullName}`, prompt: 'Deposit synthesis (no read need).' },
+    deposit: { id: `deposit-${input.repositoryFullName}` },
+    sourceRevision: {
+      repositoryFullName: input.repositoryFullName,
+      branch: input.branch || 'main',
+      commit: input.commit || input.revision,
+    },
+    source: {
+      type: 'git',
+      url: `https://github.com/${input.repositoryFullName}.git`,
+      revision: input.revision,
+      username: input.token ? 'x-access-token' : undefined,
+      password: input.token,
+      depth: 1,
+    },
+    depositSteering: {
+      obfuscations: input.obfuscations,
+      protectedIpExclusions: input.protectedIpExclusions,
+      demandContext: input.demandContext,
+    },
+  });
+  const host = input.hostFactory
+    ? await input.hostFactory()
+    : new VercelSandboxPipelineHost({
+        sandboxFactory: await loadVercelSandboxFactory(),
+        onEvent: input.onEvent,
+      });
+  const result = await host.runHarness(plan);
+  const evidence = result?.artifacts?.evidence as { depositOptions?: unknown } | null;
+  return evidence && Array.isArray(evidence.depositOptions) ? evidence.depositOptions : [];
+}
+
 /**
  * Provision the full checkout on the Host and build the deposit inventory from it.
  * Reads every tracked file's verbatim content (`sources`, for measurement), derives

uapi/tests/api/depositSynthesizeOptionsRoute.test.ts

@@ -46,20 +46,28 @@ jest.mock('@bitcode/pipeline-asset-pack', () => ({
 jest.mock('@/lib/deposit-source-provisioning', () => ({
   resolveDepositPipelineHost: jest.fn(() => ({ capabilities: { hostKind: 'inline' } })),
   provisionDepositSourceInventory: jest.fn(),
+  selectDepositHostKind: jest.fn(() => 'inline'),
+  runDepositInBoxHarness: jest.fn(),
 }));
 
 import { createClient } from '@bitcode/supabase/ssr/server';
 import { supabaseAdmin } from '@bitcode/supabase';
 import { createStreamingExecution } from '@bitcode/pipelines-generics';
 import { synthesizeAssetPacksPipeline } from '@bitcode/pipeline-asset-pack';
 import { isAssetPackRealInferenceEnabled } from '@bitcode/pipeline-asset-pack/runtime-inference-policy';
-import { provisionDepositSourceInventory } from '@/lib/deposit-source-provisioning';
+import {
+  provisionDepositSourceInventory,
+  runDepositInBoxHarness,
+  selectDepositHostKind,
+} from '@/lib/deposit-source-provisioning';
 import { POST } from '@/app/api/deposit/synthesize-options/route';
 
 const mockRealInference = isAssetPackRealInferenceEnabled as jest.Mock;
 const mockPipeline = synthesizeAssetPacksPipeline as jest.Mock;
 const mockCreateExecution = createStreamingExecution as jest.Mock;
 const mockProvision = provisionDepositSourceInventory as jest.Mock;
+const mockSelectKind = selectDepositHostKind as jest.Mock;
+const mockRunHarness = runDepositInBoxHarness as jest.Mock;
 
 // The synthesized options the pipeline leaves at implementation:options. The route's
 // validateDepositSynthesisOptions (real) turns these into measured deposit options.
@@ -196,8 +204,13 @@ async function flushBackground(predicate: () => boolean, max = 50) {
 describe('POST /api/deposit/synthesize-options', () => {
   beforeEach(() => {
     jest.clearAllMocks();
+    // Reset queued .once() implementations (clearAllMocks does not) so a pipeline/
+    // harness mock queued by one test never leaks into the next.
+    mockPipeline.mockReset();
+    mockRunHarness.mockReset();
     mockRealInference.mockReturnValue(true);
     mockProvision.mockResolvedValue(PROVISIONED);
+    mockSelectKind.mockReturnValue('inline');
   });
 
   it('requires a session', async () => {
@@ -268,6 +281,30 @@ describe('POST /api/deposit/synthesize-options', () => {
     expect(completed.output.reviewProjections[0].coveredSourcePaths).toEqual(['README.md', 'src/app.py']);
   });
 
+  it('runs the synthesis in-box on the sandbox host when configured (#25)', async () => {
+    const { executionRow } = installSupabaseMocks({});
+    installExecutionMock();
+    mockSelectKind.mockReturnValue('sandbox');
+    mockRunHarness.mockResolvedValue(RAW_OPTIONS);
+
+    const response = await POST(createRequest());
+    expect(response.status).toBe(200);
+
+    await flushBackground(() =>
+      executionRow.upsert.mock.calls.some((call) => call[0]?.status === 'completed'),
+    );
+    // Dispatched to the in-box harness; the in-process pipeline + provisioning were NOT run.
+    expect(mockRunHarness).toHaveBeenCalledTimes(1);
+    expect(mockPipeline).not.toHaveBeenCalled();
+    expect(mockProvision).not.toHaveBeenCalled();
+    const completed = executionRow.upsert.mock.calls.find((call) => call[0]?.status === 'completed')![0];
+    expect(completed.output.depositOptionSynthesis.optionCount).toBe(1);
+    expect(completed.output.depositOptionSynthesis.options[0].contents.provenantSourcePaths).toEqual([
+      'README.md',
+      'src/app.py',
+    ]);
+  });
+
   it('persists a failed row when the background synthesis throws', async () => {
     const { executionRow } = installSupabaseMocks({});
     installExecutionMock({ failPipeline: true });

uapi/tests/lib/depositSourceProvisioning.test.ts

@@ -4,6 +4,7 @@
 import {
   provisionDepositSourceInventory,
   resolveDepositPipelineHost,
+  runDepositInBoxHarness,
   selectDepositHostKind,
 } from '@/lib/deposit-source-provisioning';
 import type { BitcodeHostWorkspace, BitcodePipelineHost } from '@bitcode/pipeline-hosts';
@@ -108,3 +109,49 @@ describe('resolveDepositPipelineHost', () => {
     await expect(resolveDepositPipelineHost()).rejects.toThrow(/not yet wired/i);
   });
 });
+
+describe('runDepositInBoxHarness (#25)', () => {
+  it('dispatches a deposit-mode harness and returns evidence.depositOptions', async () => {
+    let receivedPlan: any;
+    const fakeHost = {
+      runHarness: async (plan: any) => {
+        receivedPlan = plan;
+        return {
+          artifacts: { evidence: { depositOptions: [{ title: 'Auth slice', coveredSourcePaths: ['src/auth.ts'] }] }, telemetry: null },
+          outcome: 'completed',
+          stopped: true,
+          manifest: plan.manifest,
+          commands: [],
+        };
+      },
+    };
+    const options = await runDepositInBoxHarness({
+      repositoryFullName: 'engineeredsoftware/demo',
+      revision: 'abc123',
+      branch: 'main',
+      commit: 'abc123',
+      token: 'ghs_tok',
+      obfuscations: 'hide internal names',
+      protectedIpExclusions: ['secret/'],
+      demandContext: ['auth'],
+      hostFactory: async () => fakeHost,
+    });
+
+    expect(options).toEqual([{ title: 'Auth slice', coveredSourcePaths: ['src/auth.ts'] }]);
+    // The dispatched plan ran the deposit lens in-box, with a git source + steering.
+    expect(receivedPlan.manifest.synthesizeMode).toBe('deposit');
+    expect(receivedPlan.manifest.depositSteering).toMatchObject({ protectedIpExclusions: ['secret/'] });
+    expect(receivedPlan.createOptions.source).toMatchObject({ type: 'git', revision: 'abc123' });
+  });
+
+  it('returns [] when the evidence has no depositOptions', async () => {
+    const fakeHost = {
+      runHarness: async () => ({ artifacts: { evidence: {}, telemetry: null }, outcome: 'completed', stopped: true, manifest: {}, commands: [] }),
+    };
+    const options = await runDepositInBoxHarness({
+      repositoryFullName: 'o/r', revision: 'main', branch: 'main', commit: null,
+      obfuscations: null, protectedIpExclusions: [], demandContext: [], hostFactory: async () => fakeHost,
+    });
+    expect(options).toEqual([]);
+  });
+});