V48 Gate 3 (implementation-only): Settled demand honesty and full-stack deposit stats

Ground earnings/neediness in settled Depository AssetPack search or show
Unestimatable; re-ground option neediness after synthesis. Keep Positive ROI
reviewable when demand is unestimatable (provisional ROI ranking; earnings
display still unestimatable). Fix permanent Required denials=2 by treating
sub-critical deposit authority as ready without depositApproved first.

Author: geraldarthurdavis

packages/pipelines/asset-pack/package.json

@@ -17,6 +17,7 @@
     "./deposit-asset-pack-option-policy": "./src/deposit-asset-pack-option-policy.ts",
     "./deposit-asset-pack-option-admission": "./src/deposit-asset-pack-option-admission.ts",
     "./depositor-earning-supply-intelligence": "./src/depositor-earning-supply-intelligence.ts",
+    "./depository-settled-demand-estimate": "./src/depository-settled-demand-estimate.ts",
     "./btd-btc-compensation-statements": "./src/btd-btc-compensation-statements.ts",
     "./asset-pack-commodity-state": "./src/asset-pack-commodity-state.ts",
     "./btd-scalar-volume-quote": "./src/btd-scalar-volume-quote.ts",

packages/pipelines/asset-pack/src/__tests__/depositor-earning-supply-intelligence.test.ts

@@ -106,4 +106,30 @@ describe('Depositor earning supply intelligence', () => {
     expect(assertDepositorEarningSupplyIntelligenceSourceSafe(intelligence).admitted).toBe(true);
     expect(JSON.stringify(intelligence)).not.toContain('PRIVATE_SOURCE_DO_NOT_SERIALIZE');
   });
+
+  it('marks likely demand and compensation unestimatable without inventing placeholders', () => {
+    const intelligence = buildDepositorEarningSupplyIntelligence({
+      policyReport: reviewablePolicyReport(),
+      demandUnestimatable: true,
+      demandUnestimatableRationale:
+        'Unestimatable: the Depository has no settled AssetPacks to search for comparable demand.',
+      unfitNeedOpportunitySignals: [
+        {
+          id: 'should-be-ignored',
+          label: 'Must not surface when demand is unestimatable.',
+          weight: 0.99,
+        },
+      ],
+    });
+
+    expect(intelligence.likelyDemand.state).toBe('unestimatable-demand');
+    expect(intelligence.likelyDemand.averageConfidence).toBe(0);
+    expect(intelligence.unfitNeedOpportunities.state).toBe('unestimatable-demand');
+    expect(intelligence.unfitNeedOpportunities.opportunityCount).toBe(0);
+    expect(
+      intelligence.earningStatements.every((statement) => statement.state === 'unestimatable-demand'),
+    ).toBe(true);
+    expect(intelligence.aggregate.totalExpectedCompensationSats).toBe(0);
+    expect(intelligence.aggregate.eligibleEarningStatementCount).toBe(0);
+  });
 });

packages/pipelines/asset-pack/src/__tests__/depository-settled-demand-estimate.test.ts

@@ -0,0 +1,168 @@
+import {
+  estimateDepositorySettledDemand,
+  groundOptionNeedinessFromSettledDepository,
+  settledDemandEstimateToNeediness,
+  settledDemandEstimateToSignals,
+  type SettledDepositoryPackSummary,
+} from '../depository-settled-demand-estimate';
+
+function pack(
+  id: string,
+  overrides: Partial<SettledDepositoryPackSummary> = {},
+): SettledDepositoryPackSummary {
+  return {
+    id,
+    title: overrides.title ?? `Settled pack ${id}`,
+    summary: overrides.summary ?? 'Source-safe settled AssetPack summary for demand search.',
+    kind: overrides.kind ?? 'capability-slice',
+    repositoryFullName: overrides.repositoryFullName ?? 'acme/widgets',
+    lifecycleState: overrides.lifecycleState ?? 'settled',
+    topics: overrides.topics ?? ['auth', 'routing'],
+  };
+}
+
+describe('depository settled demand estimate', () => {
+  it('returns unestimatable when the settled corpus is empty', () => {
+    const estimate = estimateDepositorySettledDemand({ settledPacks: [] });
+    expect(estimate.estimatable).toBe(false);
+    expect(estimate.state).toBe('unestimatable-demand');
+    expect(estimate.demand).toBeNull();
+    expect(estimate.needinessVolume).toBeNull();
+    expect(estimate.rationale).toMatch(/^Unestimatable:/);
+    expect(settledDemandEstimateToSignals(estimate).depositoryDemandSignals).toEqual([]);
+    expect(settledDemandEstimateToNeediness(estimate).estimatable).toBe(false);
+  });
+
+  it('returns unestimatable when below the settled floor', () => {
+    const estimate = estimateDepositorySettledDemand({
+      settledPacks: [pack('a'), pack('b')],
+      minSettledPacks: 3,
+    });
+    expect(estimate.estimatable).toBe(false);
+    expect(estimate.settledPackCount).toBe(2);
+    expect(estimate.rationale).toMatch(/need at least 3/);
+  });
+
+  it('estimates aggregate demand from a settled corpus without inventing strong placeholders', () => {
+    const settledPacks = [
+      pack('1', { title: 'Auth capability slice', summary: 'Reusable authentication capability' }),
+      pack('2', { title: 'Routing pattern', summary: 'HTTP routing implementation pattern' }),
+      pack('3', { title: 'Proof ops', summary: 'Operations proof for deposit route' }),
+      pack('4', { title: 'Telemetry slice', summary: 'Telemetry collection capability' }),
+    ];
+    const estimate = estimateDepositorySettledDemand({ settledPacks });
+    expect(estimate.estimatable).toBe(true);
+    expect(estimate.demand).not.toBeNull();
+    expect(estimate.demand!).toBeGreaterThan(0);
+    expect(estimate.demand!).toBeLessThanOrEqual(1);
+    expect(estimate.saturation).not.toBeNull();
+    expect(estimate.needinessVolume).not.toBeNull();
+    expect(estimate.rationale).toMatch(/settled Depository AssetPack/i);
+    const signals = settledDemandEstimateToSignals(estimate);
+    expect(signals.depositoryDemandSignals[0]?.weight).toBe(estimate.demand);
+  });
+
+  it('returns unestimatable for a focused topic with no matching settled packs', () => {
+    const settledPacks = [
+      pack('1', { title: 'Auth capability', summary: 'login session tokens' }),
+      pack('2', { title: 'Auth middleware', summary: 'session cookies' }),
+      pack('3', { title: 'Identity bridge', summary: 'oauth providers' }),
+    ];
+    const estimate = estimateDepositorySettledDemand({
+      settledPacks,
+      focus: {
+        title: 'Quantum ledger warp core',
+        summary: 'Hyperdimensional quantum entanglement settlement primitives',
+        kind: 'proof-operations-slice',
+        repositoryFullName: 'other/org',
+      },
+    });
+    expect(estimate.estimatable).toBe(false);
+    expect(estimate.state).toBe('unestimatable-demand');
+    expect(estimate.rationale).toMatch(/no settled Depository AssetPacks match/i);
+  });
+
+  it('raises demand for topic-aligned settled packs with low corpus coverage', () => {
+    const settledPacks = [
+      pack('1', {
+        title: 'Deposit route proof operations',
+        summary: 'Source-safe deposit route proof and admission',
+        kind: 'proof-operations-slice',
+        repositoryFullName: 'engineeredsoftware/ENGI',
+        topics: ['deposit', 'route', 'proof'],
+      }),
+      pack('2', {
+        title: 'Deposit admission receipt',
+        summary: 'Depository admission for deposit options',
+        kind: 'proof-operations-slice',
+        repositoryFullName: 'engineeredsoftware/ENGI',
+        topics: ['deposit', 'admission'],
+      }),
+      pack('3', {
+        title: 'Unrelated widget inventory',
+        summary: 'Inventory of garden widgets and tools',
+        kind: 'capability-slice',
+        repositoryFullName: 'acme/widgets',
+        topics: ['garden', 'widgets'],
+      }),
+      pack('4', {
+        title: 'Widget shipping labels',
+        summary: 'Shipping label generation for widgets',
+        kind: 'implementation-pattern',
+        repositoryFullName: 'acme/widgets',
+        topics: ['shipping'],
+      }),
+      pack('5', {
+        title: 'Widget color palette',
+        summary: 'Color tokens for the widget catalog',
+        kind: 'capability-slice',
+        repositoryFullName: 'acme/widgets',
+        topics: ['design'],
+      }),
+    ];
+    const estimate = estimateDepositorySettledDemand({
+      settledPacks,
+      focus: {
+        title: 'Deposit route proof operations slice',
+        summary: 'Source-safe deposit route proof and Depository admission evidence',
+        kind: 'proof-operations-slice',
+        repositoryFullName: 'engineeredsoftware/ENGI',
+        coveredSourcePaths: ['uapi/app/deposits/DepositPageClient.tsx'],
+      },
+    });
+    expect(estimate.estimatable).toBe(true);
+    expect(estimate.matchedPackCount).toBeGreaterThan(0);
+    expect(estimate.demand).toBeGreaterThan(0);
+    expect(settledDemandEstimateToNeediness(estimate).estimatable).toBe(true);
+  });
+
+  it('grounds option neediness from settled packs or marks Unestimatable', () => {
+    const options = [
+      {
+        title: 'Auth capability slice',
+        summary: 'Reusable authentication capability from the repository',
+        kind: 'capability-slice',
+        neediness: { volume: 0.86, demand: 0.9, saturation: 0.1, rationale: 'LLM invented' },
+        contents: { provenantSourcePaths: ['src/auth.ts'] },
+        sourceBinding: { repositoryFullName: 'acme/widgets' },
+      },
+    ];
+
+    const thin = groundOptionNeedinessFromSettledDepository(options, []);
+    expect(thin[0].neediness?.rationale).toMatch(/^Unestimatable:/);
+    expect(thin[0].neediness?.demand).toBe(0);
+
+    const settledPacks = [
+      pack('1', { title: 'Auth capability', summary: 'authentication sessions' }),
+      pack('2', { title: 'Auth middleware', summary: 'login authentication middleware' }),
+      pack('3', { title: 'Session store', summary: 'authentication session store pattern' }),
+    ];
+    const grounded = groundOptionNeedinessFromSettledDepository(options, settledPacks);
+    expect(grounded[0].neediness?.rationale).not.toBe('LLM invented');
+    // Either estimatable from matches or honest Unestimatable — never silent invent.
+    expect(
+      grounded[0].neediness?.rationale?.includes('settled') ||
+        grounded[0].neediness?.rationale?.startsWith('Unestimatable'),
+    ).toBe(true);
+  });
+});

packages/pipelines/asset-pack/src/__tests__/organization-policy-wallet-authority.test.ts

@@ -104,6 +104,39 @@ describe('OrganizationPolicyWalletAuthority', () => {
     expect(statement.disclosure.protectedSourceVisible).toBe(false);
   });
 
+  it('authorizes approve/submit when sub-critical without requiring depositApproved first (no permanent Required denials)', () => {
+    const statement = buildOrganizationPolicyWalletAuthority({
+      route: '/deposits',
+      actorId: 'user-1',
+      organizationId: 'org-1',
+      organizationRole: 'admin',
+      organizationPermissionGrants: [
+        'deposit:synthesize_options',
+        'deposit:approve_option',
+        'deposit:submit',
+      ],
+      walletId: 'wallet-depositor',
+      walletAuthorityPresent: true,
+      sourceCriticalityState: 'sub-critical',
+      sourceCriticalityApproved: true,
+      depositApproved: false,
+      expectedSettlementSats: 5_200,
+      depositLimitSats: 100_000,
+      accountAdmitted: true,
+      interfaceAdmitted: true,
+    });
+
+    expect(statement.depositApproval.state).toBe('sub-critical-approved');
+    expect(statement.aggregate.requiredDeniedActionCount).toBe(0);
+    expect(statement.aggregate.state).toBe('allowed');
+    expect(
+      statement.actionStatements.find((entry) => entry.action === 'approve_deposit_option'),
+    ).toMatchObject({ allowed: true });
+    expect(
+      statement.actionStatements.find((entry) => entry.action === 'submit_deposit'),
+    ).toMatchObject({ allowed: true });
+  });
+
   it('blocks critical source deposit approval without exposing source-bearing payloads', () => {
     const statement = buildOrganizationPolicyWalletAuthority({
       route: '/deposits',