V48 Gate 3 (implementation-only): SDIVF CI integration, fail-closed absolutes, deposit impl key

- Opt-in BITCODE_ENABLE_ASSET_PACK_SDIVF_RUNTIME_IN_TEST runs all five phases under test
- Deposit SDIVF integration suite (boundary-mocked LLMs) proves full deposit spine
- validateDepositSynthesisOptions fail-closes without formal absolutes (no placeholder fallback)
- ReadyToFinish unwraps PTRR envelope (F26-A/F27 class)
- Deposit implementation agent key: implementation:deposit-asset-pack-synthesis
- Deprecate non-product synthesizeRealDepositOptionCandidates dual-core path

Author: geraldarthurdavis

packages/pipelines/asset-pack/src/__tests__/agent-measure-absolutes.test.ts

@@ -144,12 +144,11 @@ describe('validateDepositSynthesisOptions absolutes wiring', () => {
     expect(measurements.map((m) => m.measurementKind)).not.toContain('source-coverage');
   });
 
-  it('falls back to the placeholder catalog when no absolutes are present', () => {
+  it('fail-closes when formal absolutes are missing (no placeholder catalog fallback)', () => {
     const out = validateDepositSynthesisOptions([baseOption], context);
-    const kinds = out.candidates[0].measurements.map((m) => m.measurementKind);
-    expect(kinds).toContain('source-coverage');
-    expect(kinds).toContain('demand-alignment');
-    expect(kinds).toContain('reuse-likelihood');
+    expect(out.candidates).toHaveLength(0);
+    expect(out.droppedCandidateCount).toBe(1);
+    expect(out.exclusionViolations[0]).toMatch(/missing formal absolute measurements/i);
   });
 });
 

packages/pipelines/asset-pack/src/__tests__/asset-packs-synthesis.test.ts

@@ -199,6 +199,27 @@ describe('deposit lens adapter', () => {
           measurements: { 'source-coverage': 0.6, 'demand-alignment': 0.7, 'reuse-likelihood': 0.5 },
           measurementRationale: 'Covers the auth path.',
           confidence: 0.8,
+          // Formal absolutes (Validation measure-agent) are required — no
+          // placeholder catalog fallback on the product projection path.
+          absolutes: [
+            {
+              measurementKind: 'function-count',
+              label: 'Functions',
+              weight: 0.12,
+              volume: 0.5,
+              category: 'absolute',
+              magnitude: 8,
+              unit: 'functions',
+            },
+            {
+              measurementKind: 'correctness-estimate',
+              label: 'Correctness',
+              weight: 0.18,
+              volume: 0.7,
+              category: 'absolute',
+              unit: 'estimate',
+            },
+          ],
           patch: {
             fileChanges: [
               { path: 'src/app.py', op: 'modify' },

packages/pipelines/asset-pack/src/__tests__/deposit-sdivf-pipeline-integration.test.ts

@@ -0,0 +1,237 @@
+// @ts-nocheck
+/**
+ * Deposit SDIVF pipeline integration (V48 Gate 3 — P0 CI confidence).
+ *
+ * Under NODE_ENV=test the five phase runtimes are no-ops by default. This suite
+ * opts into the real phase runtimes via BITCODE_ENABLE_ASSET_PACK_SDIVF_RUNTIME_IN_TEST
+ * and runs the full deposit lens with boundary-mocked LLMs only — never real
+ * provider inference. Pins:
+ *   - Setup → Discovery → Implementation → Validation → Finish all execute
+ *   - implementation:options is produced on the shared execution
+ *   - Validation attaches formal absolutes (deterministic measure path)
+ *   - Finish records the upload-for-review artifact
+ *
+ * Clone/MCP setup agents that need live VCS are stubbed so the suite stays offline.
+ */
+jest.mock('@bitcode/generic-llms', () =>
+  require('./support/generic-llms-mock').makeGenericLLMsMock());
+
+jest.mock('../agents/setup/asset-pack-clone-vcs-repository-agent', () => ({
+  __esModule: true,
+  default: jest.fn().mockResolvedValue({
+    success: true,
+    repository: {
+      owner: 'engineeredsoftware',
+      name: 'ENGI',
+      fullName: 'engineeredsoftware/ENGI',
+      branch: 'main',
+    },
+  }),
+}));
+
+jest.mock('../agents/setup/asset-pack-initialize-mcps-tools-agent', () => ({
+  __esModule: true,
+  default: jest.fn().mockResolvedValue({ success: true }),
+}));
+
+import { Execution } from '@bitcode/execution-generics';
+import {
+  setBoundaryLLMOutput,
+  resetBoundaryLLMOutput,
+  resetBoundaryLLMCalls,
+} from './support/generic-llms-mock';
+import { synthesizeAssetPacksPipeline } from '../index';
+import { validateDepositSynthesisOptions } from '../asset-packs-synthesis';
+
+const INVENTORY = {
+  paths: ['src/auth/session.ts', 'src/auth/token.ts', 'src/billing/invoice.ts'],
+  samples: [
+    {
+      path: 'src/auth/session.ts',
+      excerpt: 'export function createSession() { return { id: 1 }; }',
+    },
+  ],
+  totalPathCount: 3,
+  excludedPathCount: 0,
+};
+
+/** One boundary response that satisfies every deposit agent schema (non-strict). */
+const DEPOSIT_SDIVF_BOUNDARY_OUTPUT = {
+  // Setup + discovery:comprehension-shaped agents
+  comprehension: {
+    summary: 'Auth and billing capabilities with clear module boundaries.',
+    obfuscatedPaths: [],
+    obfuscatedConcepts: [],
+    honorNotes: [],
+    capabilities: ['session auth', 'token refresh', 'invoicing'],
+    knowledgeAreas: ['authentication', 'billing'],
+    notableModules: ['src/auth/session.ts', 'src/billing/invoice.ts'],
+  },
+  // Discovery depository-search
+  guidance: {
+    summary: 'Readers seek reusable auth and billing slices.',
+    likelyReadTopics: ['authentication', 'billing'],
+    demandAlignment: ['session auth'],
+    underservedTopics: ['token refresh patterns'],
+    readabilityNotes: ['Keep paths source-safe.'],
+  },
+  // Discovery inherent-regurgitation
+  regurgitation: {
+    summary: 'Known session/token patterns and invoice domain practices.',
+    relevantKnowledge: ['JWT refresh rotation', 'idempotent invoicing'],
+    patterns: ['capability-slice packaging'],
+    references: ['industry auth handbooks'],
+  },
+  // Implementation synthesis
+  options: [
+    {
+      kind: 'capability-slice',
+      title: 'Auth session capability slice',
+      summary:
+        'A bounded source-safe authentication capability covering session creation and token refresh for reusable deposit supply.',
+      coveredSourcePaths: ['src/auth/session.ts', 'src/auth/token.ts'],
+      measurements: {},
+      measurementRationale: '',
+      confidence: 0.82,
+      patch: {
+        fileChanges: [
+          { path: 'src/auth/session.ts', op: 'modify' },
+          { path: 'src/auth/token.ts', op: 'create' },
+        ],
+        patchSummary: 'Encodes session and token refresh capability as deposit supply.',
+      },
+      needinessSignal: {
+        demand: 0.7,
+        saturation: 0.3,
+        rationale: 'Auth knowledge is frequently read across the network.',
+      },
+    },
+  ],
+  // Deposit validation
+  issues: [],
+  qualityScore: 0.88,
+  coverageGaps: [],
+  recommendation: 'complete',
+  // ReadyToFinish
+  ready: true,
+  assessment: {
+    productionReady: true,
+    qualityLevel: 'good',
+    riskLevel: 'low',
+    recommendation: 'Finish and upload for depositor review.',
+  },
+  criticalIssues: [],
+  warnings: [],
+  suggestions: [],
+  metrics: {
+    overallScore: 0.88,
+    validationScore: 0.9,
+    qualityScore: 0.88,
+    readinessScore: 0.9,
+  },
+};
+
+describe('deposit SDIVF pipeline integration (boundary-mocked LLMs)', () => {
+  const previousSdivf = process.env.BITCODE_ENABLE_ASSET_PACK_SDIVF_RUNTIME_IN_TEST;
+  const previousInference = process.env.BITCODE_ASSET_PACK_REAL_INFERENCE;
+
+  beforeAll(() => {
+    process.env.BITCODE_ENABLE_ASSET_PACK_SDIVF_RUNTIME_IN_TEST = '1';
+    // Deterministic absolutes (Tool path); quality volumes stay report-derived.
+    delete process.env.BITCODE_ASSET_PACK_REAL_INFERENCE;
+  });
+
+  afterAll(() => {
+    if (previousSdivf === undefined) {
+      delete process.env.BITCODE_ENABLE_ASSET_PACK_SDIVF_RUNTIME_IN_TEST;
+    } else {
+      process.env.BITCODE_ENABLE_ASSET_PACK_SDIVF_RUNTIME_IN_TEST = previousSdivf;
+    }
+    if (previousInference === undefined) {
+      delete process.env.BITCODE_ASSET_PACK_REAL_INFERENCE;
+    } else {
+      process.env.BITCODE_ASSET_PACK_REAL_INFERENCE = previousInference;
+    }
+  });
+
+  beforeEach(() => {
+    resetBoundaryLLMOutput();
+    resetBoundaryLLMCalls();
+    setBoundaryLLMOutput(DEPOSIT_SDIVF_BOUNDARY_OUTPUT);
+  });
+
+  it(
+    'runs all five deposit SDIVF phases and leaves measured options + finish upload on the shared execution',
+    async () => {
+      const execution = new Execution('deposit-sdivf-integration');
+
+      await synthesizeAssetPacksPipeline(
+        {
+          mode: 'deposit',
+          synthesizeMode: 'deposit',
+          repositoryFullName: 'engineeredsoftware/ENGI',
+          sourceBranch: 'main',
+          sourceCommit: '31bbc0c5227b6b3aed5d107fd8507d35ec22970a',
+          repository: {
+            owner: 'engineeredsoftware',
+            name: 'ENGI',
+            repo: 'ENGI',
+            branch: 'main',
+            commit: '31bbc0c5227b6b3aed5d107fd8507d35ec22970a',
+            fullName: 'engineeredsoftware/ENGI',
+            url: 'https://github.com/engineeredsoftware/ENGI',
+          },
+          obfuscations: 'Withhold secret signing internals.',
+          protectedIpExclusions: [],
+          demandContext: ['authentication'],
+          inventory: INVENTORY,
+          candidateKinds: [
+            'capability-slice',
+            'implementation-pattern',
+            'proof-operations-slice',
+          ],
+        },
+        execution,
+      );
+
+      const options =
+        execution.get('implementation', 'options') ??
+        execution.findUp('implementation', 'options');
+      expect(Array.isArray(options)).toBe(true);
+      expect(options.length).toBeGreaterThanOrEqual(1);
+      expect(options[0].title).toMatch(/auth/i);
+      expect(options[0].patch?.fileChanges?.length).toBeGreaterThan(0);
+
+      // Validation measure-agent attaches formal absolutes in place.
+      expect(Array.isArray(options[0].absolutes)).toBe(true);
+      expect(options[0].absolutes.length).toBeGreaterThan(0);
+      expect(
+        options[0].absolutes.some((m) => m.measurementKind === 'function-count'),
+      ).toBe(true);
+
+      // Product projection must accept formal absolutes (no placeholder fallback).
+      const validated = validateDepositSynthesisOptions(options, {
+        lens: 'deposit',
+        inventoryPaths: INVENTORY.paths,
+        protectedIpExclusions: [],
+        candidateKinds: [
+          'capability-slice',
+          'implementation-pattern',
+          'proof-operations-slice',
+        ],
+      });
+      expect(validated.candidates.length).toBeGreaterThanOrEqual(1);
+      expect(
+        validated.candidates[0].measurements.map((m) => m.measurementKind),
+      ).not.toContain('source-coverage');
+
+      const upload =
+        execution.get('finish', 'uploadForReview') ??
+        execution.findUp('finish', 'uploadForReview');
+      expect(upload?.success).toBe(true);
+      expect(upload?.deliveryMechanism).toBe('bitcode-review-upload');
+      expect(upload?.review?.surface).toBe('/deposits');
+    },
+    180000,
+  );
+});

packages/pipelines/asset-pack/src/__tests__/synthesize-asset-packs-phase-rosters.test.ts

@@ -90,19 +90,20 @@ describe('per-mode agent rosters (conditional runtime registries)', () => {
     },
   );
 
-  it('implementation registers the mode-appropriate synthesis agent under the SHARED key', async () => {
-    const sharedKey = 'implementation:ReadFitsFindingSynthesisAssetPackSynthesisAgent';
+  it('implementation registers deposit-named vs read-era synthesis keys by mode', async () => {
+    const depositKey = 'implementation:deposit-asset-pack-synthesis';
+    const readKey = 'implementation:ReadFitsFindingSynthesisAssetPackSynthesisAgent';
 
     const depositRegistry = fakeRegistry();
     registerImplementationAgents(depositRegistry, 'deposit');
-    expect(Array.from(depositRegistry.entries.keys())).toEqual([sharedKey]);
-    expect(await resolveEntry(depositRegistry.entries.get(sharedKey)))
+    expect(Array.from(depositRegistry.entries.keys())).toEqual([depositKey]);
+    expect(await resolveEntry(depositRegistry.entries.get(depositKey)))
       .toBe(depositAssetPackSynthesisAgent);
 
     const readRegistry = fakeRegistry();
     registerImplementationAgents(readRegistry, 'read');
-    expect(Array.from(readRegistry.entries.keys())).toEqual([sharedKey]);
-    expect(await resolveEntry(readRegistry.entries.get(sharedKey)))
+    expect(Array.from(readRegistry.entries.keys())).toEqual([readKey]);
+    expect(await resolveEntry(readRegistry.entries.get(readKey)))
       .toBe(readFitsFindingSynthesisAssetPackSynthesisAgent);
   });
 
@@ -228,7 +229,8 @@ const READ_DISCOVERY_KEYS = [
   'discovery:plan-implementation',
   'discovery:assess-complexity',
 ];
-const IMPLEMENTATION_KEY = 'implementation:ReadFitsFindingSynthesisAssetPackSynthesisAgent';
+const DEPOSIT_IMPLEMENTATION_KEY = 'implementation:deposit-asset-pack-synthesis';
+const READ_IMPLEMENTATION_KEY = 'implementation:ReadFitsFindingSynthesisAssetPackSynthesisAgent';
 const READ_VALIDATION_KEYS = [
   'validation:validate-last-iterations-validation-phase',
   'validation:validate-discovery-phase',
@@ -271,12 +273,14 @@ describe('phase delegators execute the mode roster in order (execution-tree walk
     expect(calls).toEqual(READ_DISCOVERY_KEYS);
   });
 
-  it('implementation resolves the single shared synthesis key in both modes', async () => {
+  it('implementation resolves the mode-appropriate synthesis key', async () => {
     for (const mode of ['deposit', 'read'] as const) {
-      const { calls, root } = harness(mode, [IMPLEMENTATION_KEY]);
+      const key =
+        mode === 'deposit' ? DEPOSIT_IMPLEMENTATION_KEY : READ_IMPLEMENTATION_KEY;
+      const { calls, root } = harness(mode, [key]);
       const output = await implementationPhase({ seed: true }, root.child('seq-2'));
-      expect(calls).toEqual([IMPLEMENTATION_KEY]);
-      expect(output[`ran:${IMPLEMENTATION_KEY}`]).toBe(true);
+      expect(calls).toEqual([key]);
+      expect(output[`ran:${key}`]).toBe(true);
     }
   });
 

packages/pipelines/asset-pack/src/agents/validation/asset-pack-ready-to-finish-agent.ts

@@ -157,16 +157,20 @@ export default async function readyToFinishWithShortCircuit(input: any, executio
     qualityMetrics: {}
   };
 
-  // Execute the agent
-  const result = await readyToFinishAgent(finishInput, execution);
+  // Execute the agent — factoryAgentWithPTRR returns an envelope
+  // {context, output, finalOutput}; typed fields live ONLY inside it (F26-A/F27).
+  const raw = await readyToFinishAgent(finishInput, execution);
+  const result = ((raw as any)?.finalOutput ??
+    (raw as any)?.output ??
+    raw) as Output;
 
   // Define critical failure thresholds
   const QUALITY_THRESHOLD = 0.5;
   const CONFIDENCE_THRESHOLD = 0.6;
-  const CRITICAL_RISK = result.assessment.riskLevel === 'critical';
-  const POOR_QUALITY = result.assessment.qualityLevel === 'poor';
-  const LOW_CONFIDENCE = result.confidence < CONFIDENCE_THRESHOLD;
-  const LOW_QUALITY = result.metrics.overallScore < QUALITY_THRESHOLD;
+  const CRITICAL_RISK = result.assessment?.riskLevel === 'critical';
+  const POOR_QUALITY = result.assessment?.qualityLevel === 'poor';
+  const LOW_CONFIDENCE = (result.confidence ?? 0) < CONFIDENCE_THRESHOLD;
+  const LOW_QUALITY = (result.metrics?.overallScore ?? 0) < QUALITY_THRESHOLD;
 
   // Check if we should short-circuit
   const shouldShortCircuit =
@@ -175,7 +179,7 @@ export default async function readyToFinishWithShortCircuit(input: any, executio
     POOR_QUALITY ||
     LOW_CONFIDENCE ||
     LOW_QUALITY ||
-    result.criticalIssues.length > 0;
+    (result.criticalIssues?.length ?? 0) > 0;
 
   if (shouldShortCircuit) {
     // Persist readiness signal for header rendering
@@ -195,7 +199,7 @@ export default async function readyToFinishWithShortCircuit(input: any, executio
     if (POOR_QUALITY) reasons.push('Poor quality assessment');
     if (LOW_CONFIDENCE) reasons.push(`Low confidence (${result.confidence.toFixed(2)})`);
     if (LOW_QUALITY) reasons.push(`Low quality score (${result.metrics.overallScore.toFixed(2)})`);
-    if (result.criticalIssues.length > 0) {
+    if ((result.criticalIssues?.length ?? 0) > 0) {
       reasons.push(`Critical issues: ${result.criticalIssues.slice(0, 3).join(', ')}`);
     }