V48 Gate 3 (implementation-only): wire agent-measure-absolutes into the Validation phase (formal absolutes flow to the /deposit options)

Completes the absolutes formalization: the Validation phase now MEASURES each synthesized patch's absolutes via the formal measure-agent, and the formal absolutes flow through to the /deposit option tiles — replacing the synthesis agent's inline self-scored placeholder catalog as the effective measurement.

- deposit-validation-agent.ts: after the quality verdict, run measureAssetPackAbsolutes per synthesized pack (parallel; each LLM call F25-timeout-bounded; deterministic descriptor-derived fallback when real inference is off), attach the absolutes to each pack in place, and re-store implementation:options/assetPacks (the exact keys the route + Finish read). The measure-agent's PTRR substeps render in the SDIVF telemetry, content withheld.
- asset-packs-synthesis.ts: validateDepositSynthesisOptions now PREFERS option.absolutes (the formal measurements) as the candidate's measurements; the legacy inline-record catalog mapping is the back-compat fallback (bounded path / pre-Gate-4 read lens).
- deposit-asset-pack-options.ts: widened DepositAssetPackOptionMeasurement.measurementKind to string + carries category/magnitude/unit. deposit-option-real-synthesis.ts projects those through.
- DepositPageClient.tsx: the measurement tile surfaces the size magnitude (e.g. "12 functions · 60% / weight 0.18").

Verified: asset-pack 44 suites/216 tests, agent-generics 8/16, uapi depositPageClient 2/2, all green; tsc clean for asset-pack + uapi. The deterministic fallback + absolutes-preferred-when-present keep the bounded-synthesis path working.

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

Author: geraldarthurdavis

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

@@ -8,6 +8,7 @@ import {
 import {
   ASSET_PACK_ABSOLUTES_CATALOG,
   ASSET_PACK_ABSOLUTE_KINDS,
+  validateDepositSynthesisOptions,
 } from '../asset-packs-synthesis';
 
 const PATCH: MeasurableAssetPackPatch = {
@@ -70,3 +71,45 @@ describe('agent-measure-absolutes', () => {
     expect(deposit.measurementSpecs).toHaveLength(ASSET_PACK_ABSOLUTES_CATALOG.length);
   });
 });
+
+describe('validateDepositSynthesisOptions absolutes wiring', () => {
+  const baseOption = {
+    kind: 'capability-slice',
+    title: 'Auth capability slice',
+    summary: 'A reusable authentication capability extracted from the source.',
+    coveredSourcePaths: ['src/auth.ts'],
+    measurements: { 'source-coverage': 0.7, 'demand-alignment': 0.6, 'reuse-likelihood': 0.5 },
+    measurementRationale: 'Covers the auth module.',
+    confidence: 0.8,
+  };
+  const context = {
+    lens: 'deposit' as const,
+    inventoryPaths: ['src/auth.ts'],
+    protectedIpExclusions: [],
+    candidateKinds: ['capability-slice', 'implementation-pattern', 'proof-operations-slice'],
+  };
+
+  it('prefers the formal absolutes over the placeholder catalog', () => {
+    const absolutes = [
+      { measurementKind: 'function-count', label: 'Functions', weight: 0.18, volume: 0.5, category: 'absolute', magnitude: 12, unit: 'functions' },
+      { measurementKind: 'semantic-volume', label: 'Semantic volume', weight: 0.28, volume: 0.66, category: 'absolute', unit: 'normalized' },
+    ];
+    const out = validateDepositSynthesisOptions([{ ...baseOption, absolutes }], context);
+    const measurements = out.candidates[0].measurements;
+    expect(measurements.map((m) => m.measurementKind)).toEqual(['function-count', 'semantic-volume']);
+    const fn = measurements.find((m) => m.measurementKind === 'function-count');
+    expect(fn?.magnitude).toBe(12);
+    expect(fn?.category).toBe('absolute');
+    expect(fn?.unit).toBe('functions');
+    // placeholder kinds are NOT present once formal absolutes are supplied
+    expect(measurements.map((m) => m.measurementKind)).not.toContain('source-coverage');
+  });
+
+  it('falls back to the placeholder catalog when no absolutes are present', () => {
+    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');
+  });
+});

packages/pipelines/asset-pack/src/agents/validation/deposit-validation-agent.ts

@@ -27,6 +27,7 @@ import { Prompt } from '@bitcode/prompts/prompt';
 import type { PromptPart } from '@bitcode/prompts/parts/PromptPart';
 import { z } from 'zod';
 import { DEPOSIT_MEASUREMENT_CATALOG } from '../../asset-packs-synthesis';
+import { measureAssetPackAbsolutes } from './agent-measure-absolutes';
 
 const part = (content: string): PromptPart => content as PromptPart;
 
@@ -291,5 +292,43 @@ export default async function runDepositValidationAgent(input: any, execution: a
     execution.store('validation', 'depositQuality', result);
   } catch {}
 
+  // V48 Gate 3 — formal ABSOLUTES measurement. Each AssetPack is a measured patch:
+  // the patch was synthesized in Implementation; here the formal measure-agent
+  // (agent-measure-absolutes) MEASURES its absolutes (sizes / correctness /
+  // semantic-volume) and attaches them to the pack in place. Real inference runs
+  // the measure-agent (its PTRR substeps render in the SDIVF telemetry, content
+  // withheld); otherwise the deterministic descriptor-derived fallback applies.
+  // Per pack in parallel so wall-clock ≈ one measurement; each LLM call is bounded
+  // by the F25 per-call timeout.
+  if (packs.length > 0) {
+    await Promise.all(
+      packs.map(async (pack: any) => {
+        try {
+          const absolutes = await measureAssetPackAbsolutes(
+            {
+              title: String(pack?.title ?? ''),
+              summary: String(pack?.summary ?? ''),
+              coveredSourcePaths: asPathList(pack?.coveredSourcePaths),
+              fileChanges: Array.isArray(pack?.patch?.fileChanges) ? pack.patch.fileChanges : undefined,
+              confidence: typeof pack?.confidence === 'number' ? pack.confidence : undefined,
+              patchSummary:
+                typeof pack?.patch?.patchSummary === 'string' ? pack.patch.patchSummary : undefined,
+            },
+            { lens: 'deposit', execution },
+          );
+          // Attach the formal absolutes to the measured patch in place; the route's
+          // validateDepositSynthesisOptions prefers these over the legacy inline record.
+          pack.absolutes = absolutes;
+        } catch {}
+      }),
+    );
+    try {
+      // Re-store the measured packs (in-place mutation + explicit re-store) under the
+      // exact keys the route + Finish read.
+      execution.store('implementation', 'options', packs);
+      execution.store('implementation', 'assetPacks', packs);
+    } catch {}
+  }
+
   return { ...(input || {}), ...result };
 }

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

@@ -502,6 +502,10 @@ export function validateDepositSynthesisOptions(
     measurements: Record<string, number>;
     measurementRationale: string;
     confidence: number;
+    // V48 Gate 3: the FORMAL absolutes measured by agent-measure-absolutes in the
+    // Validation phase. When present these are the candidate's measurements (the
+    // legacy `measurements` record is the back-compat fallback only).
+    absolutes?: AssetPackCandidateMeasurement[] | null;
     // Deposit lens only: the read-demand preview signal (v0). neediness is
     // COMPUTED from this; absent/invalid signals yield no neediness preview.
     needinessSignal?: { demand?: number; saturation?: number; rationale?: string } | null;
@@ -534,12 +538,28 @@ export function validateDepositSynthesisOptions(
       );
       continue;
     }
-    const measurements = catalog.map((spec) => ({
-      measurementKind: spec.measurementKind,
-      label: spec.label,
-      weight: spec.weight,
-      volume: clampVolume(option.measurements?.[spec.measurementKind] ?? 0),
-    }));
+    // Prefer the FORMAL absolutes (agent-measure-absolutes, Validation phase) when
+    // present; otherwise map the legacy inline record through the lens catalog.
+    const formalAbsolutes = Array.isArray(option.absolutes) ? option.absolutes : null;
+    const measurements: AssetPackCandidateMeasurement[] =
+      formalAbsolutes && formalAbsolutes.length > 0
+        ? formalAbsolutes.map((m) => ({
+            measurementKind: String(m.measurementKind),
+            label: String(m.label ?? m.measurementKind),
+            weight: Number.isFinite(m.weight) ? Number(m.weight) : 0,
+            volume: clampVolume(Number(m.volume) || 0),
+            category: m.category === 'neediness' ? 'neediness' : 'absolute',
+            ...(Number.isFinite(m.magnitude as number)
+              ? { magnitude: Math.max(0, Math.round(Number(m.magnitude))) }
+              : {}),
+            ...(m.unit ? { unit: String(m.unit) } : {}),
+          }))
+        : catalog.map((spec) => ({
+            measurementKind: spec.measurementKind,
+            label: spec.label,
+            weight: spec.weight,
+            volume: clampVolume(option.measurements?.[spec.measurementKind] ?? 0),
+          }));
     candidates.push({
       kind: allowedKinds.has(option.kind) ? option.kind : context.candidateKinds[0],
       title: String(option.title).trim(),

packages/pipelines/asset-pack/src/deposit-asset-pack-options.ts

@@ -30,9 +30,18 @@ export interface DepositOptionSynthesisRequest {
 export interface DepositAssetPackOptionMeasurement {
   id: string;
   label: string;
-  measurementKind: 'source-coverage' | 'demand-alignment' | 'reuse-likelihood';
+  // V48 Gate 3: widened to the absolutes catalog kinds (function-count, type-count,
+  // file-span, correctness-estimate, semantic-volume) — the formal measurements —
+  // as well as the legacy placeholder kinds the deterministic blueprint emits.
+  measurementKind: string;
   weight: number;
   volume: number;
+  /** Which measurement category — absolutes form the weighted composite. */
+  category?: 'absolute' | 'neediness';
+  /** Raw count for size measurements (functions / types / files). */
+  magnitude?: number;
+  /** functions | types | files | estimate | normalized. */
+  unit?: string;
   evidenceRoot: string;
 }
 

packages/pipelines/asset-pack/src/deposit-option-real-synthesis.ts

@@ -180,9 +180,13 @@ export function buildRealDepositAssetPackOptionSynthesis(
     const measurements: DepositAssetPackOptionMeasurement[] = candidate.measurements.map((measurement) => ({
       id: `${optionId}:${measurement.measurementKind}`,
       label: measurement.label,
-      measurementKind: measurement.measurementKind as DepositAssetPackOptionMeasurement['measurementKind'],
+      measurementKind: measurement.measurementKind,
       weight: measurement.weight,
       volume: measurement.volume,
+      // V48 Gate 3: carry the absolutes provenance (category + size magnitude/unit).
+      ...(measurement.category ? { category: measurement.category } : {}),
+      ...(typeof measurement.magnitude === 'number' ? { magnitude: measurement.magnitude } : {}),
+      ...(measurement.unit ? { unit: measurement.unit } : {}),
       evidenceRoot: root('deposit-option-measurement', {
         measurementKind: measurement.measurementKind,
         weight: measurement.weight,

uapi/app/deposit/DepositPageClient.tsx

@@ -1687,8 +1687,26 @@ export default function DepositPageClient() {
                               {measurement.label}
                             </dt>
                             <dd className="mt-1 text-sm text-neutral-200">
-                              {(measurement.volume * 100).toFixed(0)}% / weight{" "}
-                              {measurement.weight.toFixed(2)}
+                              {typeof measurement.magnitude === "number" ? (
+                                <>
+                                  {measurement.magnitude}
+                                  {measurement.unit &&
+                                  measurement.unit !== "normalized" &&
+                                  measurement.unit !== "estimate"
+                                    ? ` ${measurement.unit}`
+                                    : ""}
+                                  <span className="text-neutral-500">
+                                    {" "}
+                                    · {(measurement.volume * 100).toFixed(0)}% / weight{" "}
+                                    {measurement.weight.toFixed(2)}
+                                  </span>
+                                </>
+                              ) : (
+                                <>
+                                  {(measurement.volume * 100).toFixed(0)}% / weight{" "}
+                                  {measurement.weight.toFixed(2)}
+                                </>
+                              )}
                             </dd>
                           </div>
                         ))}