pi-daddy 0.41.0 → 0.43.0

package/extensions/delegation-ledger.ts

@@ -54,6 +54,8 @@ export async function recordDelegationDecision(input: {
       humanDenied: approval?.humanDenied ?? approvalFacts?.humanDenied,
       gateOutcome: approval?.gateOutcome,
       definitionDigest: plan.definitionDigest,
+      definitionHash: plan.definitionHash,
+      definitionPackageVersion: plan.definitionPackageVersion,
       taskDigest: plan.taskDigest,
       correlation: plan.correlation,
       refusal: plan.refusal,

package/extensions/delegation.ts

@@ -37,6 +37,7 @@ import { newDelegationOccurrence } from "./execution-occurrence.ts";
 import { correlationShape as buildCorrelationShape } from "./correlation-shape.ts";
 import { assertDelegationAuthority } from "./delegation-authority.ts";
 import { contextShape } from "./context-shape.ts";
+import { ensureSessionModelPrompt } from "./session-model-prompt.ts";
 
 /**
  * Wire a set of children to pi's partial-result channel — ADR-0032.
@@ -201,6 +202,9 @@ export function registerDelegationTools(pi: ExtensionAPI, session: GrantsSession
       maxItems: MAX_CHILDREN_PER_CALL,
       description: "The sub-agents to run concurrently. Each is independent and unaware of the others.",
     }),
+    episodeCostCeiling: Type.Optional(
+      Type.Number({ exclusiveMinimum: 0, description: "Override the USD ceiling for this whole episode." }),
+    ),
   });
 
   const delegateParams = Type.Object({
@@ -223,6 +227,9 @@ export function registerDelegationTools(pi: ExtensionAPI, session: GrantsSession
       }),
     ),
     thinking: thinkingShape,
+    episodeCostCeiling: Type.Optional(
+      Type.Number({ exclusiveMinimum: 0, description: "Override the USD ceiling for this whole episode." }),
+    ),
     context: Type.Optional(contextShape()),
     correlation: Type.Optional(correlationShape),
     workspace: Type.Optional(workspaceShape),
@@ -239,6 +246,11 @@ export function registerDelegationTools(pi: ExtensionAPI, session: GrantsSession
     parameters: delegateParams,
     async execute(_toolCallId, params, signal, onUpdate, ctx) {
       assertDelegationAuthority(session);
+      await ensureSessionModelPrompt(session, params.agent ? [params.agent] : [], {
+        hasUI: ctx.hasUI && typeof ctx.ui.input === "function",
+        input: (title, placeholder) => ctx.ui.input(title, placeholder),
+        notify: (message, type) => ctx.ui.notify(message, type),
+      });
       // ADR-0032: one child, same block. `_onUpdate` was discarded here, so a delegation showed the bare word
       // `delegate` for up to DEFAULT_TIMEOUT_MS — sixty minutes by default.
       const progress = progressReporter(session, [params.agent ?? "delegate"], onUpdate as never);
@@ -250,6 +262,7 @@ export function registerDelegationTools(pi: ExtensionAPI, session: GrantsSession
           tools: params.tools,
           model: params.model,
           thinking: params.thinking,
+          episodeCostCeiling: params.episodeCostCeiling,
           context: params.context,
           correlation: params.correlation,
           workspace: params.workspace,
@@ -318,6 +331,15 @@ export function registerDelegationTools(pi: ExtensionAPI, session: GrantsSession
     async execute(_toolCallId, params, signal, onUpdate, ctx) {
       assertDelegationAuthority(session);
       const children = params.children ?? [];
+      await ensureSessionModelPrompt(
+        session,
+        children.flatMap((child) => (child.agent ? [child.agent] : [])),
+        {
+          hasUI: ctx.hasUI && typeof ctx.ui.input === "function",
+          input: (title, placeholder) => ctx.ui.input(title, placeholder),
+          notify: (message, type) => ctx.ui.notify(message, type),
+        },
+      );
       const split = splitBudget(session.fanoutBudget, children.length);
       if (!split.ok) {
         // Thrown, not returned: a returned `isError` is discarded by pi, so a refusal that came back as a
@@ -325,6 +347,8 @@ export function registerDelegationTools(pi: ExtensionAPI, session: GrantsSession
         throw new GovernanceRefusal(refusal("FANOUT_EXCEEDED", `fan-out refused: ${split.reason}`));
       }
 
+      if (params.episodeCostCeiling !== undefined) session.episodeCostGate.setCeiling(params.episodeCostCeiling);
+
       // ADR-0032: ONE status block covering every child. `onUpdate` replaces the tool's rendered result, so a
       // painter per child would have each overwriting the others.
       const progress = progressReporter(

package/extensions/effort-advice.ts

@@ -14,6 +14,7 @@
  */
 import { supportedModelEfforts } from "../src/kernel/model-preflight.ts";
 import type { Advisor } from "../src/advisors/advisor.ts";
+import { resolvedModelOf, type ResolvedDefinitionRuntime } from "./definition-runtime.ts";
 
 /** What pi's resolved catalogue entry carries that decides which efforts exist. */
 interface ResolvedModel {
@@ -40,6 +41,7 @@ export async function adviseEffort(input: {
   task: string;
   executionId?: string;
   agent?: string;
+  fallback?: ResolvedDefinitionRuntime;
   signal?: AbortSignal;
 }): Promise<string | undefined> {
   const advisor = input.session.advisorSession.advisor;
@@ -71,6 +73,16 @@ export async function adviseEffort(input: {
     },
     input.signal,
     input.executionId,
+    (result) => {
+      const answer = result?.answers.effort;
+      const advised = answer?.kind === "choice" && (levels as readonly string[]).includes(answer.value);
+      return {
+        resolvedModel: resolvedModelOf(input.fallback?.model ?? input.model),
+        modelSource: input.fallback?.modelSource ?? "pi",
+        thinkingLevel: advised ? answer.value : (input.fallback?.thinking ?? null),
+        thinkingSource: advised ? "advisor" : (input.fallback?.thinkingSource ?? "pi"),
+      };
+    },
   );
   const chosen = advice?.answers.effort;
   // Belt and braces: `parseAnswer` already refuses a choice outside the options it was given, so this can only

package/extensions/execute-child.ts

@@ -4,7 +4,7 @@ import {
   retentionConfigurationDigest,
   type RetentionStatus,
 } from "../src/governance/execution-retention.ts";
-import { appendLedgerEvent, buildChildLifecycleEvent } from "../src/governance/ledger.ts";
+import { appendLedgerEvent, buildChildLifecycleEvent, buildEpisodeCostGateEvent } from "../src/governance/ledger.ts";
 import { hasFinalizerError } from "../src/governance/finalization.ts";
 import { mergeChildEnv } from "../src/kernel/propagation.ts";
 import type { Capability } from "../src/kernel/resolve.ts";
@@ -22,9 +22,11 @@ import { resolveWorkspace } from "../src/executors/herdr-cli.ts";
 import { HerdrWriterCloseError, runHerdrPane } from "../src/executors/run-herdr.ts";
 import { GovernanceRefusal, refusal, type StructuredRefusal } from "../src/kernel/refusals.ts";
 import { ENV_HERDR_KEEP_PANE, type GrantsSession } from "./session.ts";
-import { ENV_EPISODE_ID } from "../src/kernel/env-names.ts";
+import { CHILD_ATTRIBUTION_ENV_KEYS, ENV_EPISODE_ID } from "../src/kernel/env-names.ts";
 import { releaseDelegationWorkspace, type PreparedWorkspace } from "./workspace-runtime.ts";
 import { ActivityTimelineRecorder, ENV_ACTIVITY_PARENT_TASK } from "../src/products/activity-timeline.ts";
+import { loadEpisodeCosts } from "../src/governance/episode-cost-gate.ts";
+import { resolvedModelOf, type ResolvedDefinitionRuntime } from "./definition-runtime.ts";
 export interface DelegationOutcome {
   ok: boolean;
   text: string;
@@ -105,11 +107,26 @@ export async function executePlannedChild(input: {
   toolCallId?: string;
   cwd: string;
   preparedWorkspace?: PreparedWorkspace;
+  resolvedRuntime?: ResolvedDefinitionRuntime;
   signal?: AbortSignal;
   onProgress?: (update: ChildProgressUpdate) => void;
+  costGateUI?: {
+    hasUI: boolean;
+    input(title: string, placeholder: string, signal?: AbortSignal): Promise<string | undefined>;
+    notify(message: string): void;
+  };
 }): Promise<DelegationOutcome> {
   const { session, plan, childId, executionId, parentExecutionId, preparedWorkspace, signal, onProgress } = input;
   const ledgerPath = session.ledgerPath;
+  const runtimeAttribution = (observed?: {
+    resolvedModel?: { provider: string; modelId: string };
+    thinking?: string;
+  }) => ({
+    resolvedModel: observed?.resolvedModel ?? resolvedModelOf(input.resolvedRuntime?.model) ?? undefined,
+    modelSource: input.resolvedRuntime?.modelSource ?? ("pi" as const),
+    effectiveThinkingLevel: observed?.thinking ?? input.resolvedRuntime?.thinking,
+    thinkingSource: input.resolvedRuntime?.thinkingSource ?? ("pi" as const),
+  });
   let activityParent: string | undefined,
     activity = new ActivityTimelineRecorder(input.cwd),
     activityStarted = false,
@@ -165,11 +182,90 @@ export async function executePlannedChild(input: {
     // The process executor adds a second signal that is live during a tool call: the child tree's CPU time and
     // descendants (`process-activity.ts`). Herdr children are started by the daemon, so their pid is not known here.
     let childPid: number | undefined;
+    let costStopped = false;
+    const costUI = input.costGateUI ?? {
+      hasUI: false,
+      input: async () => undefined,
+      notify: () => undefined,
+    };
+    const costAbort = new AbortController();
+    const observeCost = async (cost: number | undefined, terminal: boolean) => {
+      if (!session.episodeCostGate) return;
+      if (ledgerPath) {
+        const recorded = await loadEpisodeCosts(ledgerPath, session.episodeId);
+        for (const [recordedExecution, recordedCost] of recorded) {
+          session.episodeCostGate.seedCost(recordedExecution, recordedCost);
+        }
+      }
+      await session.episodeCostGate.observe(executionId, cost, terminal, {
+        warn: (message) => costUI.notify(message),
+        pause: async () => {
+          if (session.executor.kind === "herdr") {
+            costUI.notify("pi-daddy: Herdr cannot pause a pane; stopping it at the episode cost ceiling");
+            return;
+          }
+          if (childPid !== undefined)
+            try {
+              process.kill(childPid, "SIGSTOP");
+            } catch {
+              /* the child may have exited between its final usage write and this observation */
+            }
+        },
+        ask: async () => {
+          if (session.executor.kind === "herdr" || !costUI.hasUI) return null;
+          const value = await costUI.input(
+            "pi-daddy: episode cost ceiling crossed",
+            "New USD ceiling above the current cost; leave blank to stop",
+            signal,
+          );
+          if (value === undefined || value.trim() === "") return null;
+          const parsed = Number(value);
+          return Number.isFinite(parsed) ? parsed : null;
+        },
+        resume: async () => {
+          if (childPid !== undefined)
+            try {
+              process.kill(childPid, "SIGCONT");
+            } catch {
+              /* already exited */
+            }
+        },
+        stop: async () => {
+          costStopped = true;
+          if (childPid !== undefined)
+            try {
+              process.kill(childPid, "SIGCONT");
+            } catch {
+              /* already exited */
+            }
+          costAbort.abort();
+        },
+        gate: async (event) => {
+          if (!ledgerPath) return;
+          await appendLedgerEvent(
+            {
+              path: ledgerPath,
+              strict: true,
+            },
+            buildEpisodeCostGateEvent({
+              episodeId: session.episodeId,
+              executionId,
+              parentExecutionId,
+              childId,
+              ...event,
+              now: new Date(),
+            }),
+          );
+        },
+      });
+    };
     const probe = async () => {
-      const [file, tree] = await Promise.all([
+      const [file, tree, usage] = await Promise.all([
         activitySession.probe(),
         childPid === undefined ? undefined : processTreeActivity(childPid),
+        activitySession.usage(),
       ]);
+      await observeCost(usage.usage?.cost.total, false);
       return file === undefined && tree === undefined ? undefined : `${file ?? "-"}|${tree ?? "-"}`;
     };
     const startedAt = new Date();
@@ -187,6 +283,10 @@ export async function executePlannedChild(input: {
             executor: session.executor.kind,
             deadlineAt,
             idleTimeoutMs: configuredIdleMs,
+            exportedEnvironment: CHILD_ATTRIBUTION_ENV_KEYS,
+            ...runtimeAttribution(),
+            definitionHash: plan.definitionHash,
+            definitionPackageVersion: plan.definitionPackageVersion,
             correlation: plan.correlation,
             now: startedAt,
           }),
@@ -219,11 +319,12 @@ export async function executePlannedChild(input: {
       leaseLost = true;
       leaseAbort.abort();
     });
-    const executionSignal = signal
-      ? AbortSignal.any([signal, leaseAbort.signal])
-      : writerLease
-        ? leaseAbort.signal
-        : undefined;
+    const executionSignals = [
+      costAbort.signal,
+      ...(signal ? [signal] : []),
+      ...(writerLease ? [leaseAbort.signal] : []),
+    ];
+    const executionSignal = AbortSignal.any(executionSignals);
     const retention = beginExecutionRetention({
       executionId,
       parentExecutionId,
@@ -265,6 +366,10 @@ export async function executePlannedChild(input: {
             deadlineAt,
             idleTimeoutMs: configuredIdleMs,
             ...(pane ? { herdrPaneId: pane.id, herdrAgentName: pane.agentName } : {}),
+            exportedEnvironment: CHILD_ATTRIBUTION_ENV_KEYS,
+            ...runtimeAttribution(),
+            definitionHash: plan.definitionHash,
+            definitionPackageVersion: plan.definitionPackageVersion,
             correlation: plan.correlation,
             now: new Date(),
           }),
@@ -343,6 +448,7 @@ export async function executePlannedChild(input: {
         failed: childFailed,
       });
       const usageObservation = await activitySession.usage();
+      await observeCost(usageObservation.usage?.cost.total, usageObservation.usage === undefined);
       releaseReason = output.timedOut ? "timeout" : output.aborted ? "cancelled" : childFailed ? "failed" : "completed";
       if (activityStarted)
         try {
@@ -386,9 +492,22 @@ export async function executePlannedChild(input: {
               idleTimeoutMs: configuredIdleMs,
               reason:
                 output.spawnError ?? (output.timedOut ? (output.idle ? "idle-timeout" : "wall-clock") : undefined),
+              exportedEnvironment: CHILD_ATTRIBUTION_ENV_KEYS,
+              definitionHash: plan.definitionHash,
+              definitionPackageVersion: plan.definitionPackageVersion,
+              ...runtimeAttribution({
+                ...(usageObservation.resolvedModel ? { resolvedModel: usageObservation.resolvedModel } : {}),
+                ...(usageObservation.effectiveThinkingLevel
+                  ? { thinking: usageObservation.effectiveThinkingLevel }
+                  : {}),
+              }),
+              ...(usageObservation.tokenDetail ? { tokenDetail: usageObservation.tokenDetail } : {}),
               ...(usageObservation.usage
                 ? { usage: usageObservation.usage }
                 : { usageUnavailable: usageObservation.unavailable! }),
+              ...(usageObservation.compactionCount !== undefined
+                ? { compactionCount: usageObservation.compactionCount }
+                : {}),
               correlation: plan.correlation,
               now: new Date(),
             }),
@@ -403,7 +522,9 @@ export async function executePlannedChild(input: {
           : output.aborted
             ? leaseWasLost
               ? "lost the exclusive writer lease protecting its workspace and was stopped"
-              : "was cancelled"
+              : costStopped
+                ? "crossed the episode cost ceiling and was stopped"
+                : "was cancelled"
             : output.timedOut
               ? output.idle
                 ? `showed no activity for ${describeBound(configuredIdleMs)} and was killed ` +
@@ -473,6 +594,11 @@ export async function executePlannedChild(input: {
       });
       retainWriterLease = Boolean(writerLease && isHerdrWriterCloseFailure(error));
       const usageObservation = await activitySession.usage();
+      try {
+        await observeCost(usageObservation.usage?.cost.total, usageObservation.usage === undefined);
+      } catch {
+        /* cost observation must not replace the executor's primary failure */
+      }
       if (ledgerPath && !terminalAttempted) {
         // Best-effort: this records the failure, so it must not REPLACE the failure. A strict append that
         // throws here would discard the original error — including HerdrWriterCloseError, whose whole
@@ -498,9 +624,22 @@ export async function executePlannedChild(input: {
                   : error instanceof Error
                     ? error.name
                     : "unknown executor error",
+              exportedEnvironment: CHILD_ATTRIBUTION_ENV_KEYS,
+              definitionHash: plan.definitionHash,
+              definitionPackageVersion: plan.definitionPackageVersion,
+              ...runtimeAttribution({
+                ...(usageObservation.resolvedModel ? { resolvedModel: usageObservation.resolvedModel } : {}),
+                ...(usageObservation.effectiveThinkingLevel
+                  ? { thinking: usageObservation.effectiveThinkingLevel }
+                  : {}),
+              }),
+              ...(usageObservation.tokenDetail ? { tokenDetail: usageObservation.tokenDetail } : {}),
               ...(usageObservation.usage
                 ? { usage: usageObservation.usage }
                 : { usageUnavailable: usageObservation.unavailable! }),
+              ...(usageObservation.compactionCount !== undefined
+                ? { compactionCount: usageObservation.compactionCount }
+                : {}),
               correlation: plan.correlation,
               now: new Date(),
             }),

package/extensions/grants-command.ts

@@ -20,6 +20,7 @@ import type { GatedPlan } from "./run-delegation.ts";
 import { handleConnectedCommand } from "./grants-connected-command.ts";
 import { loadApprovals, revokeAll, revokeApproval, type SubjectLookup } from "../src/governance/approval-store.ts";
 import { verifyLedger } from "../src/governance/ledger.ts";
+import type { ResolvedDefinitionRuntime } from "./definition-runtime.ts";
 
 export interface GrantsCommandContext {
   cwd: string;
@@ -60,6 +61,13 @@ export interface GrantsCommandContext {
    * R-28 discipline where it belongs: this command asks what would happen instead of working it out.
    */
   previewDelegation: (name: string) => Promise<GatedPlan>;
+  runtimeFor: (name: string) => ResolvedDefinitionRuntime;
+  changeModels: (ui: {
+    input: GrantsCommandContext["modelInput"];
+    notify: GrantsCommandContext["modelNotify"];
+  }) => Promise<string>;
+  modelInput(title: string, placeholder?: string): Promise<string | undefined>;
+  modelNotify(message: string, type?: "info" | "warning" | "error"): void;
   /**
    * Run `/grants init`: scaffold definitions, ask about withheld capabilities, atomically store grant plus
    * project-ledger consent outside the workspace, and apply both now (ADR-0030, ADR-0037).
@@ -83,7 +91,15 @@ export interface GrantsCommandContext {
 const PREVIEW_LIMIT = 12;
 
 /** The verbs `/grants` answers to. Anything else is refused rather than silently treated as no verb. */
-const KNOWN_SUBCOMMANDS: readonly string[] = ["init", "dashboard", "ledger", "approvals", "revoke", "workspaces"];
+const KNOWN_SUBCOMMANDS: readonly string[] = [
+  "init",
+  "dashboard",
+  "ledger",
+  "approvals",
+  "revoke",
+  "workspaces",
+  "models",
+];
 
 export const grantsCommand = {
   description:
@@ -110,6 +126,7 @@ export const grantsCommand = {
       inheritedApprovals,
       snapshotOf,
       previewDelegation,
+      runtimeFor,
     } = ctx.grants as GrantsCommandContext;
 
     const [sub, target] = args.trim().split(/\s+/).filter(Boolean);
@@ -127,6 +144,15 @@ export const grantsCommand = {
     )
       return;
 
+    if (sub === "models") {
+      const rendered = await ctx.grants.changeModels({
+        input: ctx.grants.modelInput,
+        notify: ctx.grants.modelNotify,
+      });
+      ctx.ui.notify(`grants: current session model overrides\n${rendered}`, "info");
+      return;
+    }
+
     if (sub === "workspaces") {
       // The one verb that WRITES, and it takes its ability to do so from the caller — the same shape
       // `/grants init` uses, so this screen cannot become a governance path by accident.
@@ -445,6 +471,10 @@ export const grantsCommand = {
     const shown = [...definitions].slice(0, PREVIEW_LIMIT);
     for (const [name] of shown) {
       const { plan, approval } = await previewDelegation(name);
+      const runtime = runtimeFor(name);
+      const runtimeText =
+        `model ${runtime.model ?? "pi default"} (${runtime.modelSource}); ` +
+        `thinking ${runtime.thinking ?? "pi default"} (${runtime.thinkingSource})`;
       // Why it is allowed, when a standing approval is the reason. An `allow` that silently depends on a
       // 30-day entry in a file elsewhere is precisely what an operator runs this command to discover, and
       // R-38 was the version of this listing that could not have told them (it said BLOCK instead).
@@ -455,7 +485,7 @@ export const grantsCommand = {
           ? `  (${approval.approved.map((c) => `${c} approved: ${approval.sources[c] ?? "?"}`).join("; ")})`
           : "";
       lines.push(
-        `    ${plan.ok ? "allow" : "BLOCK"}  ${name}` +
+        `    ${plan.ok ? "allow" : "BLOCK"}  ${name}  [${runtimeText}]` +
           (plan.ok ? `  ${plan.effective.join(", ")}${because}` : ` — ${plan.reason}`),
       );
     }

package/extensions/grants.ts

@@ -55,6 +55,9 @@ import { legacyEnvironmentWarning } from "../src/kernel/env-names.ts";
 import { agentDir } from "../src/kernel/project-paths.ts";
 import { importLegacyLedger } from "../src/governance/ledger.ts";
 import { legacyProjectLedgerPath, projectLedgerPath } from "../src/kernel/project-paths.ts";
+import { resolveDefinitionRuntime } from "./definition-runtime.ts";
+import { changeSessionModels, renderSessionModels } from "./session-model-prompt.ts";
+import { ensureDashboardSessionServer } from "./dashboard-session-server.ts";
 export default function (pi: ExtensionAPI) {
   // The path pi loads as the extension, so a child granted `tool:delegate` can be started with `-e <this>`.
   const extensionPath = (() => {
@@ -227,6 +230,7 @@ export default function (pi: ExtensionAPI) {
           pluginRoot: dashboardPluginRoot,
           preferencePath: dashboardPaths.preferencePath,
           paneStatePath: dashboardPaths.paneStatePath,
+          sessionEndpoint: await ensureDashboardSessionServer(session),
           ui: ctx.ui,
         });
       } catch (error) {
@@ -413,7 +417,7 @@ export default function (pi: ExtensionAPI) {
               await loadProjectDefinitions(session, ctx.cwd);
               delegation.refreshSpawnable();
             }),
-          openDashboard: () =>
+          openDashboard: async () =>
             openDashboardCommand({
               env: process.env,
               pid: process.pid,
@@ -421,8 +425,26 @@ export default function (pi: ExtensionAPI) {
               ledgerPath: session.ledgerPath ?? defaultActivityTimelinePath(ctx.cwd),
               pluginRoot: dashboardPluginRoot,
               paneStatePath: dashboardPaths.paneStatePath,
+              sessionEndpoint: await ensureDashboardSessionServer(session),
             }),
           previewDelegation: (name: string) => planWithApprovals(session, { task: "(preview)", agent: name }, {}, null),
+          modelInput: (title: string, placeholder?: string) => ctx.ui.input(title, placeholder),
+          modelNotify: (message: string, type?: "info" | "warning" | "error") => ctx.ui.notify(message, type),
+          changeModels: async (ui: {
+            input(title: string, placeholder?: string): Promise<string | undefined>;
+            notify(message: string, type?: "info" | "warning" | "error"): void;
+          }) => {
+            await changeSessionModels(session, { hasUI: ctx.hasUI, ...ui });
+            return renderSessionModels(session);
+          },
+          runtimeFor: (name: string) =>
+            resolveDefinitionRuntime({
+              definition: name,
+              explicit: {},
+              session: session.definitionRuntimeOverrides,
+              settings: session.definitionRuntimeSettings,
+              piModel: ctx.model ? `${ctx.model.provider}/${ctx.model.id}` : undefined,
+            }),
         },
       }),
   });

package/extensions/pruning-advice.ts

@@ -15,7 +15,7 @@
  * selection stands — the same "identical to today" property the effort decision point has.
  */
 import { selectPrunedTurns, type ContextRequest } from "../src/kernel/context-handoff.ts";
-import type { Advisor } from "../src/advisors/advisor.ts";
+import type { AdviceAttribution, Advisor } from "../src/advisors/advisor.ts";
 import type { Question } from "../src/advisors/decider.ts";
 
 export const PRUNING_PURPOSE = "handoff-pruning";
@@ -39,6 +39,7 @@ export async function advisePruning(input: {
   executionId?: string;
   /** The current delegation call, excluded from advisor input because its arguments contain the raw task. */
   toolCallId?: string;
+  attribution?: AdviceAttribution;
   signal?: AbortSignal;
 }): Promise<string[] | undefined> {
   if (input.granted.mode !== "pruned" || !input.session.parentSession) return undefined;
@@ -85,6 +86,7 @@ export async function advisePruning(input: {
     { state: {}, questions },
     input.signal,
     input.executionId,
+    input.attribution,
   );
   if (!advice) return undefined;
   // Every candidate or none. A response missing eleven of twelve answers would otherwise read as "drop eleven",

package/extensions/run-delegation.ts

@@ -32,6 +32,8 @@ import { GovernanceRefusal, refusal as structuredRefusal } from "../src/kernel/r
 import { executePlannedChild, type DelegationOutcome } from "./execute-child.ts";
 import { recordDelegationDecision, type ApprovalLedgerFacts } from "./delegation-ledger.ts";
 import type { ExecutionOccurrenceIds } from "./execution-occurrence.ts";
+import { ENV_EPISODE_COST_CEILING } from "../src/kernel/env-names.ts";
+import { resolvedModelOf, resolveDefinitionRuntime } from "./definition-runtime.ts";
 import {
   governedWorkspaceAccess,
   prepareDelegationWorkspace,
@@ -47,6 +49,8 @@ interface ChildSpec {
   tools?: string[];
   model?: string;
   thinking?: string;
+  /** Positive USD override for the whole episode, applied only when this delegation will run. */
+  episodeCostCeiling?: number;
   /** ADR-0078: what of the parent's session crosses. Validated in the kernel, never here. */
   context?: unknown;
   correlation?: CorrelationMetadata;
@@ -246,14 +250,25 @@ export async function runOneDelegation(
   // pi resolves a BARE model id to an unauthenticated provider and the child dies at startup — the id
   // alone is not enough, it must be qualified with its provider (`Model<Api>` carries both).
   const defaultModel = ctx.model ? `${ctx.model.provider}/${ctx.model.id}` : undefined;
+  const configured = resolveDefinitionRuntime({
+    definition: spec.agent,
+    explicit: { model: spec.model, thinking: spec.thinking },
+    session: session.definitionRuntimeOverrides,
+    settings: session.definitionRuntimeSettings,
+    piModel: defaultModel,
+  });
+  let resolvedRuntime = configured;
   const request = {
     task: spec.task,
     agent: spec.agent,
     tools: spec.tools,
-    model: spec.model ?? defaultModel,
+    model: configured.model,
     // Filled below, once the refusals that doom a delegation are known: asking first shipped the task text for a
     // child that never starts, which is the ordering this module already fixed for the approval dialog.
-    thinking: spec.thinking,
+    thinking:
+      configured.thinkingSource === "explicit" || configured.thinkingSource === "session"
+        ? configured.thinking
+        : undefined,
     context: spec.context,
     correlation: spec.workspace
       ? { ...(spec.correlation ?? {}), workspace_id: spec.workspace.workspace_id }
@@ -296,17 +311,28 @@ export async function runOneDelegation(
 
   // ADR-0077's first decision point, after the refusal checks for the reason above. Fills a blank from the levels
   // the CHILD's model reports; never overrules a caller, and yields today's behaviour whenever there is no answer.
-  if (!executorRefusal && !modelRefusal)
-    request.thinking = await adviseEffort({
+  if (!executorRefusal && !modelRefusal) {
+    const advisedThinking = await adviseEffort({
       session,
-      requested: spec.thinking,
-      model: spec.model ?? defaultModel,
+      requested: request.thinking,
+      model: configured.model,
       registry: ctx.modelRegistry,
       task: spec.task,
       executionId: ids.executionId,
       agent: spec.agent,
+      fallback: configured,
       signal,
     });
+    resolvedRuntime = resolveDefinitionRuntime({
+      definition: spec.agent,
+      explicit: { model: spec.model, thinking: spec.thinking },
+      session: session.definitionRuntimeOverrides,
+      settings: session.definitionRuntimeSettings,
+      piModel: defaultModel,
+      advisorThinking: advisedThinking,
+    });
+    request.thinking = resolvedRuntime.thinking;
+  }
 
   const planContext = await handoffPlanContext({
     session,
@@ -316,6 +342,12 @@ export async function runOneDelegation(
     toolCallId,
     blocked: Boolean(executorRefusal || modelRefusal),
     preview: () => planWithApprovals(session, request, extra, null, signal, preApproved).then((r) => r.plan),
+    attribution: {
+      resolvedModel: resolvedModelOf(resolvedRuntime.model),
+      modelSource: resolvedRuntime.modelSource,
+      thinkingLevel: resolvedRuntime.thinking ?? null,
+      thinkingSource: resolvedRuntime.thinkingSource,
+    },
     ...(signal ? { signal } : {}),
   });
   let preparedWorkspace: PreparedWorkspace | undefined;
@@ -427,6 +459,14 @@ export async function runOneDelegation(
     };
   }
 
+  if (spec.episodeCostCeiling !== undefined) session.episodeCostGate.setCeiling(spec.episodeCostCeiling);
+  plan = {
+    ...plan,
+    env: { ...plan.env, [ENV_EPISODE_COST_CEILING]: String(session.episodeCostGate.ceiling) },
+  };
+  const costUI = ctx.ui as typeof ctx.ui & {
+    input(title: string, placeholder?: string, opts?: { signal?: AbortSignal }): Promise<string | undefined>;
+  };
   return executePlannedChild({
     session,
     plan,
@@ -437,8 +477,14 @@ export async function runOneDelegation(
     toolCallId: options.toolCallId,
     cwd: ctx.cwd,
     preparedWorkspace,
+    resolvedRuntime,
     signal,
     onProgress,
+    costGateUI: {
+      hasUI: ctx.hasUI,
+      input: (title, placeholder, gateSignal) => costUI.input(title, placeholder, { signal: gateSignal }),
+      notify: (message) => ctx.ui.notify(message, "warning"),
+    },
   });
 }
 
@@ -462,6 +508,7 @@ export async function handoffPlanContext(input: {
   blocked: boolean;
   /** Plans with no human in the loop; its result decides whether an advisor is consulted at all. */
   preview: () => Promise<{ handoff?: { mode: string } }>;
+  attribution?: Parameters<typeof advisePruning>[0]["attribution"];
   signal?: AbortSignal;
 }): Promise<Record<string, unknown>> {
   if (input.blocked) return { ...input.base };
@@ -473,6 +520,7 @@ export async function handoffPlanContext(input: {
     task: input.task,
     ...(input.executionId ? { executionId: input.executionId } : {}),
     ...(input.toolCallId ? { toolCallId: input.toolCallId } : {}),
+    ...(input.attribution ? { attribution: input.attribution } : {}),
     ...(input.signal ? { signal: input.signal } : {}),
   });
   return ids ? { ...input.base, handoffTurnIds: ids } : { ...input.base };