pi-background-tasks 2.1.4 → 2.4.0

package/src/core/{fusion/anthropic-attribution.ts → anthropic-attribution.ts}

@@ -64,13 +64,17 @@ const AUDIT_ENV = 'PIPELINE_ANTHROPIC_ATTRIBUTION_AUDIT_PATH';
 const CACHE_RETENTION_ENV = 'PI_CACHE_RETENTION';
 export const ANTHROPIC_CACHE_RETENTION_ENTRY = 'pipeline-anthropic-cache-retention';
 const ANTHROPIC_CACHE_RETENTION_SCHEMA = 'pipeline.anthropic_cache_retention.v1';
+export const ANTHROPIC_ATTRIBUTION_CLAIM_CHANNEL = 'pi-anthropic-attribution:claim:v1';
+const ANTHROPIC_ATTRIBUTION_CLAIM_SCHEMA = 'pi-anthropic-attribution.claim.v1';
 const NATIVE_ATTESTATION_PLACEHOLDER = '00000';
 const ANTHROPIC_CACHE_CONTROL_BREAKPOINT_LIMIT = 4;
 
-// Source: ravshansbox/pi-anthropic-sps. Keep exact-match semantics so the
-// repo-local attribution shim is idempotent with the global sanitizer.
+// Sanitization behavior derived from the MIT-licensed ravshansbox/pi-anthropic-sps
+// extension at commit 17409b5615f0ec0625776bc5434f92f2c55e3fd0. Keep exact-match
+// semantics and all known Pi prompt variants; unrelated system text is preserved.
 const ANTHROPIC_SYSTEM_PROMPT_BAD_LINES = new Set([
   '- When asked about: extensions (docs/extensions.md, examples/extensions/), themes (docs/themes.md), skills (docs/skills.md), prompt templates (docs/prompt-templates.md), TUI components (docs/tui.md), keybindings (docs/keybindings.md), SDK integrations (docs/sdk.md), custom providers (docs/custom-provider.md), adding models (docs/models.md), pi packages (docs/packages.md)',
+  '- When asked about: extensions (docs/extensions.md, examples/extensions/), themes (docs/themes.md), skills (docs/skills.md), prompt templates (docs/prompt-templates.md), TUI components (docs/tui.md), keybindings (docs/keybindings.md), SDK integrations (docs/sdk.md), custom providers (docs/custom-provider.md), adding models (docs/models.md), pi packages (docs/packages.md), environment variables (docs/environment-variables.md)',
   '- When working on pi topics, read the docs and examples, and follow .md cross-references before implementing',
 ]);
 
@@ -329,7 +333,13 @@ interface PiCommandConfigLike {
   readonly handler: (args: string, ctx: PiContextLike) => Promise<void> | void;
 }
 
+interface PiEventBusLike {
+  emit(channel: string, data: unknown): void;
+  on(channel: string, handler: (data: unknown) => void): () => void;
+}
+
 export interface PiExtensionHost extends PiProviderRegistrationHost {
+  readonly events: PiEventBusLike;
   on(
     eventName: 'session_start' | 'session_shutdown' | 'session_tree' | 'before_agent_start',
     handler: (event: unknown, ctx: PiContextLike) => void,
@@ -1867,11 +1877,54 @@ function cacheRetentionLabel(retention: CacheRetention): string {
   }
 }
 
+interface AnthropicAttributionClaimProbe {
+  readonly schema_version: typeof ANTHROPIC_ATTRIBUTION_CLAIM_SCHEMA;
+  readonly acknowledge: () => void;
+}
+
+function isAnthropicAttributionClaimProbe(value: unknown): value is AnthropicAttributionClaimProbe {
+  return (
+    isPlainObject(value) &&
+    value['schema_version'] === ANTHROPIC_ATTRIBUTION_CLAIM_SCHEMA &&
+    typeof value['acknowledge'] === 'function'
+  );
+}
+
+/**
+ * Prevent two independently installed copies from registering duplicate provider
+ * hooks and `/claude-cache` commands in one Pi runtime. Pi loads extension factories
+ * sequentially and its EventBus dispatches listeners synchronously, so an existing
+ * owner acknowledges this probe before emit() returns. The winning extension only
+ * publishes ownership after every registration below succeeds; a factory that throws
+ * cannot strand a false claim that suppresses a healthy later copy.
+ */
 export default function spawnAnthropicAttribution(pi: PiExtensionHost): void {
+  const acknowledgements: true[] = [];
+  const probe: AnthropicAttributionClaimProbe = {
+    schema_version: ANTHROPIC_ATTRIBUTION_CLAIM_SCHEMA,
+    acknowledge: () => {
+      acknowledgements.push(true);
+    },
+  };
+  pi.events.emit(ANTHROPIC_ATTRIBUTION_CLAIM_CHANNEL, probe);
+  if (acknowledgements.length > 0) return;
+
   let sessionCacheRetention: Exclude<CacheRetention, 'none'> | undefined;
   const getSessionOverride = (): Exclude<CacheRetention, 'none'> | undefined =>
     sessionCacheRetention;
 
+  // Registration is global but route-scoped by provider name. Keeping it at
+  // factory scope avoids lifecycle-dependent provider availability; the custom
+  // transport derives session/model headers from the attributed payload.
+  pi.registerProvider('anthropic', {
+    api: 'anthropic-messages',
+    streamSimple: (model, context, options) =>
+      streamAnthropicViaBetaMessages(model, context, {
+        ...(options ?? {}),
+        cacheRetention: resolveCacheRetentionPreference(options, getSessionOverride()),
+      }),
+  });
+
   pi.registerCommand('claude-cache', {
     description: 'Show or set Claude cache retention for this session (short, long, default)',
     handler: (args, ctx) => {
@@ -1902,7 +1955,6 @@ export default function spawnAnthropicAttribution(pi: PiExtensionHost): void {
 
   pi.on('session_start', (_event, ctx) => {
     sessionCacheRetention = restoreAnthropicSessionCacheRetention(ctx.sessionManager.getBranch());
-    registerAnthropicAttributionProvider(pi, ctx, getSessionOverride);
   });
 
   pi.on('session_shutdown', () => {
@@ -1913,13 +1965,8 @@ export default function spawnAnthropicAttribution(pi: PiExtensionHost): void {
     sessionCacheRetention = restoreAnthropicSessionCacheRetention(ctx.sessionManager.getBranch());
   });
 
-  pi.on('before_agent_start', (_event, ctx) => {
-    registerAnthropicAttributionProvider(pi, ctx, getSessionOverride);
-  });
-
   pi.on('before_provider_request', (event, ctx) => {
     if (!isAnthropicContext(ctx)) return undefined;
-    registerAnthropicAttributionProvider(pi, ctx, getSessionOverride);
     return rewriteAnthropicRequestPayload({
       payload: event.payload,
       ctx,
@@ -1927,4 +1974,10 @@ export default function spawnAnthropicAttribution(pi: PiExtensionHost): void {
       headerRegistered: true,
     });
   });
+
+  // Publish ownership last. Extension loading is sequential, so later independent
+  // copies probe this responder and become inert instead of registering duplicates.
+  pi.events.on(ANTHROPIC_ATTRIBUTION_CLAIM_CHANNEL, (value) => {
+    if (isAnthropicAttributionClaimProbe(value)) value.acknowledge();
+  });
 }

package/src/core/attested-pi-run.ts

@@ -150,9 +150,18 @@ export function attestedPiChildEnv(env: NodeJS.ProcessEnv): NodeJS.ProcessEnv {
   return out;
 }
 
-export function buildAttestedPiArgv(input: StructuredPiLaunchRequest): string[] {
+export function buildAttestedPiArgv(
+  input: StructuredPiLaunchRequest,
+  attributionExtensionPath?: string,
+): string[] {
   validateStructuredPiLaunchRequest(input);
   const args = ['pi', '--mode', 'json', '--provider', input.provider, '--model', input.model];
+  if (input.provider === 'anthropic') {
+    if (!attributionExtensionPath?.trim()) {
+      throw new Error('Anthropic attested Pi tasks require the package attribution extension');
+    }
+    args.push('--extension', attributionExtensionPath);
+  }
   if (input.thinking?.trim()) args.push('--thinking', input.thinking.trim());
   args.push(...(input.extraPiArgs ?? []), input.prompt);
   return args;

package/src/core/common.ts

@@ -3,7 +3,7 @@ import { open } from 'node:fs/promises';
 import { extname, isAbsolute, join, win32 } from 'node:path';
 import { DEFAULT_MAX_BYTES } from '@earendil-works/pi-coding-agent';
 import type { BackgroundTaskChildProcess } from './registry.js';
-import type { DelegateBudgetRouteSource } from './delegate/types.js';
+import type { DelegateBudgetRouteSource, DelegateExtensionMode } from './delegate/types.js';
 import type { FusionResultDetails, FusionUsage, FusionWorkflowId } from './fusion/types.js';
 
 export const TASK_STATUS_VALUES = ['running', 'completed', 'failed', 'killed'] as const;
@@ -87,6 +87,7 @@ export interface DelegateTaskFacts {
   childSessionId: string;
   route: { provider: string; model: string; qualifiedId: string };
   budget: DelegateBudgetRouteSource;
+  extensionMode: DelegateExtensionMode;
   autoDeliver: 'never' | 'when_small' | 'always';
   /** Set once the run reaches a terminal state and its result has been evaluated. */
   outcome?: DelegateTaskOutcome | undefined;

package/src/core/context/token-budget.ts

@@ -45,7 +45,11 @@ export const TOKEN_BUDGET_SEGMENT_KINDS = [
 ] as const;
 export type TokenBudgetSegmentKind = (typeof TOKEN_BUDGET_SEGMENT_KINDS)[number];
 
-export type TokenBudgetEstimatorScope = 'fusion' | 'delegate' | 'conservative';
+export type TokenBudgetEstimatorScope =
+  | 'fusion'
+  | 'delegate_launch'
+  | 'delegate'
+  | 'conservative';
 export type TokenBudgetDominantByteClass =
   | 'normal'
   | 'dense_ascii'
@@ -526,7 +530,7 @@ function rateSourceWarning(input: {
     return `model is not in the exact calibration backing set for family ${input.family}; using the provable 1.00 B/tok floor`;
   }
   if (input.source === 'delegate_conservative') {
-    return 'delegate scope withholds calibrated rates and uses the provable 1.00 B/tok profile for launch/runtime headroom';
+    return 'delegate launch/runtime uses the provable 1.00 B/tok profile when the prompt or route is below the backed large-prompt calibration domain';
   }
   if (input.source === 'explicit_conservative') {
     return 'explicit conservative scope uses the provable 1.00 B/tok profile';
@@ -569,7 +573,16 @@ function effectiveRateSource(input: {
       ? 'unbacked_model_floor'
       : 'unknown_provider_floor';
     effective = TOKEN_BUDGET_PROVABLE_RATE_X100;
-  } else if (input.scope === 'delegate') {
+  } else if (
+    input.scope === 'delegate' ||
+    (input.scope === 'delegate_launch' &&
+      (input.profile.concrete_known_bytes < TOKEN_BUDGET_LARGE_PROMPT_MIN_BYTES ||
+        (input.allowedInputTokens !== undefined &&
+          Math.floor(
+            (input.allowedInputTokens * TOKEN_BUDGET_DELEGATE_CONSERVATIVE_RATE_X100) /
+              TOKEN_BUDGET_RATE_SCALE,
+          ) < TOKEN_BUDGET_LARGE_PROMPT_MIN_BYTES)))
+  ) {
     source = 'delegate_conservative';
     effective = Math.min(configured, TOKEN_BUDGET_DELEGATE_CONSERVATIVE_RATE_X100);
   } else if (input.scope === 'conservative') {

package/src/core/delegate/artifacts.ts

@@ -1,4 +1,5 @@
 import { createHash } from 'node:crypto';
+import { existsSync } from 'node:fs';
 import { chmod, mkdir, open, readFile, rename, rm } from 'node:fs/promises';
 import { basename, isAbsolute, join, relative, sep } from 'node:path';
 import { canonicalJson } from '../attested-pi-run.js';
@@ -8,6 +9,7 @@ import {
   DELEGATE_MANIFEST_SCHEMA_VERSION,
   DELEGATE_RECEIPT_SCHEMA_VERSION,
   DelegateError,
+  type DelegateExtensionMode,
   type DelegateLimits,
   type DelegatePinnedRoute,
   type DelegateSpillReceipt,
@@ -44,8 +46,7 @@ export const DELEGATE_ARTIFACT_NAMES = {
   outcome: 'outcome.json',
   result: DELEGATE_RESULT_PACKAGE_FILENAME,
   childPrompt: 'child-prompt.txt',
-  childStderr: 'child.stderr.txt',
-  childStdout: 'child.stdout.txt',
+  runtimeBudget: 'runtime-budget.json',
   error: 'error.json',
 } as const;
 
@@ -67,6 +68,7 @@ export interface DelegateManifestV1 {
   cwd: string;
   child_session_id: string;
   child_session_dir: string;
+  extension_mode: DelegateExtensionMode;
   route: DelegatePinnedRoute;
   limits: DelegateLimits;
   seed_sha256: string;
@@ -111,6 +113,7 @@ export interface CreateDelegateArtifactStoreOptions {
   sessionId?: string | undefined;
   childSessionId: string;
   childSessionDir: string;
+  extensionMode: DelegateExtensionMode;
   route: DelegatePinnedRoute;
   limits: DelegateLimits;
   seedSha256: string;
@@ -175,6 +178,7 @@ export class DelegateArtifactStore {
       cwd: options.cwd,
       child_session_id: options.childSessionId,
       child_session_dir: options.childSessionDir,
+      extension_mode: options.extensionMode,
       route: options.route,
       limits: options.limits,
       seed_sha256: options.seedSha256,
@@ -228,11 +232,6 @@ export class DelegateArtifactStore {
     return this.write(DELEGATE_ARTIFACT_NAMES.budgetPlan, `${canonicalJson(plan)}\n`);
   }
 
-  async writeChildStreams(stdout: Buffer, stderr: Buffer): Promise<void> {
-    await this.write(DELEGATE_ARTIFACT_NAMES.childStdout, stdout);
-    await this.write(DELEGATE_ARTIFACT_NAMES.childStderr, stderr);
-  }
-
   /** Commit the run. The rename performed here is the single success point. */
   async commitResult(pkg: DelegateResultPackageV1): Promise<DelegateArtifactRef> {
     const ref = await this.write(
@@ -247,17 +246,23 @@ export class DelegateArtifactStore {
     try {
       return await readFile(this.resultPathAbs, 'utf8');
     } catch (error) {
+      const diagnosticNames = [
+        DELEGATE_ARTIFACT_NAMES.error,
+        DELEGATE_ARTIFACT_NAMES.outcome,
+        DELEGATE_ARTIFACT_NAMES.runtimeBudget,
+        DELEGATE_ARTIFACT_NAMES.manifest,
+      ].filter((name) => existsSync(join(this.rootAbs, name)));
       throw new DelegateError(
-        `delegate result package is not present at ${join(this.rootDisplay, DELEGATE_ARTIFACT_NAMES.result)}; the child produced no committed answer`,
+        `delegate result package could not be read at ${join(this.rootDisplay, DELEGATE_ARTIFACT_NAMES.result)}; no committed answer is available (${error instanceof Error ? error.message : String(error)})`,
         {
           code: 'result_unavailable',
           childCreated: true,
           taskId: this.manifest.task_id,
           artifactDir: this.rootDisplay,
-          preserved: [this.rootDisplay],
-          remediation: [
-            'Inspect child.stderr.txt and error.json in the artifact directory for the recorded failure.',
-          ],
+          preserved: diagnosticNames,
+          remediation: diagnosticNames.length === 0
+            ? ['No diagnostic control artifact exists; inspect the background task merged output if one was created.']
+            : [`Inspect the existing delegate control artifacts: ${diagnosticNames.join(', ')}.`],
         },
       );
     }
@@ -349,6 +354,7 @@ export class DelegateArtifactStore {
       source_call_index: input.sourceCallIndex,
       byte_length: input.payload.length,
       sha256: sha256Bytes(input.payload),
+      content_format: 'opaque_bytes',
     };
   }
 

package/src/core/delegate/budget.ts

@@ -4,7 +4,6 @@ import {
   TOKEN_BUDGET_RATE_SCALE,
   estimateInputTokens,
   knownTextSegment,
-  maxKnownTextBytesForTokens,
   resolveTokenBudgetFamily,
   utf8ByteClassBreakdown,
   allowedInputTokens,
@@ -28,11 +27,15 @@ import {
  * A delegate child is a multi-turn, tool-using agent, so its budget has two
  * distinct phases rather than Fusion's single-shot stage forecast:
  *
- * 1. Launch admission checks the frozen seed, framing, and child system prompt.
- * 2. The runtime governor checks the complete retained input before each call.
+ * 1. Launch admission checks the frozen seed, framing, and child system prompt
+ *    with the same backed family calibration used by Fusion for large prompts.
+ * 2. A separate provable 1 B/token forecast sizes the transcript-growth runway
+ *    used for explicit tool-result spilling.
+ * 3. Runtime measurements are advisory. Package-owned growth is controlled
+ *    before transcript entry; Pi and the provider own live context handling.
  *
- * Nothing here clamps, downgrades, or silently reduces. An input that does not
- * fit is a typed refusal.
+ * Nothing here clips, substitutes, or silently reduces content. Tool bytes that
+ * do not fit the retained-growth runway are preserved as hashed spill artifacts.
  */
 
 /** Output tokens reserved so the child can always finish an answer. */
@@ -54,10 +57,14 @@ export const DELEGATE_DEFAULT_TIMEOUT_SECONDS = 1200;
 export const DELEGATE_MAX_TOOL_RESULT_BYTES = 64 * 1024;
 export const DELEGATE_MAX_TOTAL_TOOL_OUTPUT_BYTES = 64 * 1024 * 1024;
 export const DELEGATE_MAX_ANSWER_BYTES = 4 * 1024 * 1024;
+/** Input runway held back for a final no-tool answer after investigation. */
+export const DELEGATE_FINALIZATION_INPUT_RESERVE_TOKENS = 32 * 1024;
+/** Remaining retained-growth runway at which the child disables tools. */
+export const DELEGATE_FINALIZATION_TRIGGER_TOKENS = 8 * 1024;
 /** Answers at or under this serialize inline; larger ones degrade explicitly. */
 export const DELEGATE_INLINE_ANSWER_BYTES = 48 * 1024;
 
-export const DELEGATE_BUDGET_POLICY_ID = 'delegate-budget-policy-v2';
+export const DELEGATE_BUDGET_POLICY_ID = 'delegate-budget-policy-v3';
 
 export interface DelegateBudgetPolicyDescriptor {
   id: typeof DELEGATE_BUDGET_POLICY_ID;
@@ -68,7 +75,11 @@ export interface DelegateBudgetPolicyDescriptor {
   safety_reserve_tokens: number;
   min_usable_input_tokens: number;
   inline_answer_bytes: number;
-  estimator_scope: 'delegate';
+  finalization_input_reserve_tokens: number;
+  finalization_trigger_tokens: number;
+  launch_estimator_scope: 'calibrated_large_prompt';
+  retained_growth_estimator_scope: 'provable_1_byte_per_token';
+  live_provider_context_owner: 'pi_and_provider';
 }
 
 export const DELEGATE_BUDGET_POLICY: DelegateBudgetPolicyDescriptor = {
@@ -80,7 +91,11 @@ export const DELEGATE_BUDGET_POLICY: DelegateBudgetPolicyDescriptor = {
   safety_reserve_tokens: DELEGATE_SAFETY_RESERVE_TOKENS,
   min_usable_input_tokens: DELEGATE_MIN_USABLE_INPUT_TOKENS,
   inline_answer_bytes: DELEGATE_INLINE_ANSWER_BYTES,
-  estimator_scope: 'delegate',
+  finalization_input_reserve_tokens: DELEGATE_FINALIZATION_INPUT_RESERVE_TOKENS,
+  finalization_trigger_tokens: DELEGATE_FINALIZATION_TRIGGER_TOKENS,
+  launch_estimator_scope: 'calibrated_large_prompt',
+  retained_growth_estimator_scope: 'provable_1_byte_per_token',
+  live_provider_context_owner: 'pi_and_provider',
 };
 
 export interface DelegateAdmissionPlanV1 {
@@ -97,17 +112,22 @@ export interface DelegateAdmissionPlanV1 {
     rate_source: TokenBudgetRateSource;
     byte_capacity_utf8_bytes: number;
   };
-  seed_utf8_bytes: number;
-  seed_multibyte_utf8_bytes: number;
+  child_prompt_utf8_bytes: number;
+  child_prompt_multibyte_utf8_bytes: number;
   system_prompt_utf8_bytes: number;
   system_prompt_multibyte_utf8_bytes: number;
   launch_utf8_bytes: number;
   launch_input_tokens_upper_bound: number;
+  conservative_launch_input_tokens: number;
+  conservative_launch_fits: boolean;
   signed_headroom_tokens: number;
   utilization_basis_points: number;
+  retained_growth_budget_tokens: number;
+  finalization_input_reserve_tokens: number;
   byte_class_breakdown: TokenBudgetByteClassBreakdown;
   dominant_byte_class: EstimateInputTokensResult['rateSource']['dominant_byte_class'];
   estimate: EstimateInputTokensResult;
+  conservative_estimate: EstimateInputTokensResult;
   fits: boolean;
   limits: DelegateLimits;
 }
@@ -167,7 +187,7 @@ export function delegateAllowedInputTokens(route: DelegatePinnedRoute): number {
 
 export interface DelegateAdmissionInput {
   route: DelegatePinnedRoute;
-  seedSerialized: string;
+  childPrompt: string;
   childSystemPrompt: string;
   limits: DelegateLimits;
 }
@@ -176,20 +196,39 @@ export interface DelegateAdmissionInput {
 export function planDelegateAdmission(input: DelegateAdmissionInput): DelegateAdmissionPlanV1 {
   const allowed = delegateAllowedInputTokens(input.route);
   const family = routeFamily(input.route);
-  const seed = utf8ByteClassBreakdown(input.seedSerialized);
+  const childPrompt = utf8ByteClassBreakdown(input.childPrompt);
   const system = utf8ByteClassBreakdown(input.childSystemPrompt);
+  const segments = [knownTextSegment(input.childPrompt), knownTextSegment(input.childSystemPrompt)];
   const estimate = estimateInputTokens({
     family: family.family,
     calibrationBacked: family.backed,
     familyResolution: family.resolution,
     allowedInputTokens: allowed,
-    scope: 'delegate',
-    segments: [knownTextSegment(input.seedSerialized), knownTextSegment(input.childSystemPrompt)],
+    scope: 'delegate_launch',
+    segments,
   });
+  const conservativeEstimate = estimateInputTokens({
+    family: family.family,
+    calibrationBacked: family.backed,
+    familyResolution: family.resolution,
+    allowedInputTokens: allowed,
+    scope: 'conservative',
+    segments,
+  });
+  // `conservativeEstimate.tokens` intentionally uses the shared estimator's
+  // calibrated multibyte diagnostic rate. The counter-forecast published as
+  // "provable" must instead use that estimator's explicit 1 B/token ceiling
+  // for multibyte bytes as well as normal/dense bytes.
+  const provableConservativeLaunchTokens =
+    conservativeEstimate.advisory.input_tokens_if_multibyte_used_provable_ceiling;
   const byteCapacity = Math.floor(
     (allowed * estimate.rateSource.effective_rate_bytes_per_token_x100) / TOKEN_BUDGET_RATE_SCALE,
   );
-  const launchBytes = seed.bytes + system.bytes;
+  const launchBytes = childPrompt.bytes + system.bytes;
+  const retainedGrowthBudget = Math.max(
+    0,
+    allowed - estimate.tokens - DELEGATE_FINALIZATION_INPUT_RESERVE_TOKENS,
+  );
   return {
     schema_version: DELEGATE_BUDGET_PLAN_SCHEMA_VERSION,
     policy: DELEGATE_BUDGET_POLICY,
@@ -204,17 +243,22 @@ export function planDelegateAdmission(input: DelegateAdmissionInput): DelegateAd
       rate_source: estimate.rateSource,
       byte_capacity_utf8_bytes: byteCapacity,
     },
-    seed_utf8_bytes: seed.bytes,
-    seed_multibyte_utf8_bytes: seed.multibyteBytes,
+    child_prompt_utf8_bytes: childPrompt.bytes,
+    child_prompt_multibyte_utf8_bytes: childPrompt.multibyteBytes,
     system_prompt_utf8_bytes: system.bytes,
     system_prompt_multibyte_utf8_bytes: system.multibyteBytes,
     launch_utf8_bytes: launchBytes,
     launch_input_tokens_upper_bound: estimate.tokens,
+    conservative_launch_input_tokens: provableConservativeLaunchTokens,
+    conservative_launch_fits: provableConservativeLaunchTokens <= allowed,
     signed_headroom_tokens: allowed - estimate.tokens,
     utilization_basis_points: utilizationBasisPoints(estimate.tokens, allowed),
+    retained_growth_budget_tokens: retainedGrowthBudget,
+    finalization_input_reserve_tokens: DELEGATE_FINALIZATION_INPUT_RESERVE_TOKENS,
     byte_class_breakdown: estimate.byte_class_breakdown,
     dominant_byte_class: estimate.rateSource.dominant_byte_class,
     estimate,
+    conservative_estimate: conservativeEstimate,
     fits: estimate.tokens <= allowed,
     limits: input.limits,
   };
@@ -226,17 +270,15 @@ function rateWarningText(rateSource: TokenBudgetRateSource, qualifiedId: string)
 }
 
 function requiredByteReduction(plan: DelegateAdmissionPlanV1): number {
-  return Math.max(
-    0,
-    plan.launch_utf8_bytes -
-      maxKnownTextBytesForTokens({
-        family: plan.route.family,
-        calibrationBacked: plan.route.rate_source.backed,
-        familyResolution: plan.route.rate_source.model_resolution,
-        allowedInputTokens: plan.route.allowed_input_tokens,
-        scope: 'delegate',
-      }),
-  );
+  const variableTokens =
+    plan.route.allowed_input_tokens - plan.route.rate_source.affine_f_tokens;
+  const maximumBytes = variableTokens <= 0
+    ? 0
+    : Math.floor(
+        (variableTokens * plan.route.rate_source.effective_rate_bytes_per_token_x100) /
+          TOKEN_BUDGET_RATE_SCALE,
+      );
+  return Math.max(0, plan.launch_utf8_bytes - maximumBytes);
 }
 
 /**
@@ -249,7 +291,7 @@ export function assertDelegateAdmission(plan: DelegateAdmissionPlanV1): void {
   if (plan.fits) return;
   const overage = plan.launch_input_tokens_upper_bound - plan.route.allowed_input_tokens;
   throw new DelegateError(
-    `bg_delegate seed does not fit the pinned route before launch. Route ${plan.route.qualified_id} allows ${String(plan.route.allowed_input_tokens)} input tokens; the frozen seed plus the child system prompt measure ${String(plan.launch_utf8_bytes)} UTF-8 bytes (<= ${String(plan.launch_input_tokens_upper_bound)} input tokens), over by ${String(overage)} tokens. Estimator family ${plan.route.family}, source ${plan.route.rate_source.source}, backed=${String(plan.route.rate_source.backed)}, dominant_byte_class=${plan.dominant_byte_class}, rate ${String(plan.route.rate_source.effective_rate_bytes_per_token_x100)}/100 B/tok + ${String(plan.route.rate_source.affine_f_tokens)} tokens.${rateWarningText(plan.route.rate_source, plan.route.qualified_id)} Required reduction is at least ${String(requiredByteReduction(plan))} UTF-8 bytes. No child process, child session, or artifact was created. Nothing was clipped, dropped, or substituted.`,
+    `bg_delegate child prompt does not fit the pinned route before launch. Route ${plan.route.qualified_id} allows ${String(plan.route.allowed_input_tokens)} input tokens; the exact child prompt plus child system prompt measure ${String(plan.launch_utf8_bytes)} UTF-8 bytes (<= ${String(plan.launch_input_tokens_upper_bound)} input tokens), over by ${String(overage)} tokens. Estimator family ${plan.route.family}, source ${plan.route.rate_source.source}, backed=${String(plan.route.rate_source.backed)}, dominant_byte_class=${plan.dominant_byte_class}, rate ${String(plan.route.rate_source.effective_rate_bytes_per_token_x100)}/100 B/tok + ${String(plan.route.rate_source.affine_f_tokens)} tokens.${rateWarningText(plan.route.rate_source, plan.route.qualified_id)} Required reduction is at least ${String(requiredByteReduction(plan))} UTF-8 bytes. No child process, child session, or artifact was created. Nothing was clipped, dropped, or substituted.`,
     {
       code: 'seed_budget_exceeded',
       childCreated: false,
@@ -291,10 +333,13 @@ export interface DelegateGovernorVerdict {
 }
 
 /**
- * Runtime governor decision for one prospective model call.
+ * Advisory runtime measurement for one prospective model call.
  *
- * Pure and total, so the child guard can call it from inside a hook with no
- * possibility of throwing where a throw would be swallowed.
+ * This deliberately uses the calibrated large-prompt policy and never decides
+ * whether transport may occur. Fusion's BUG-185 proved that a package-local
+ * estimator must not reject a live provider payload by subtracting hypothetical
+ * output. The delegate child uses this result for evidence and graceful
+ * finalization while proactive spilling controls package-owned growth.
  */
 export function evaluateDelegateRuntimeBudget(
   measurement: DelegateRuntimeMeasurement,
@@ -307,7 +352,7 @@ export function evaluateDelegateRuntimeBudget(
     calibrationBacked: family.backed,
     familyResolution: family.resolution,
     allowedInputTokens: allowedTokens,
-    scope: 'delegate',
+    scope: 'delegate_launch',
     segments: [
       {
         kind: 'known_text',