pi-daddy 0.41.0 → 0.43.0

package/src/governance/ledger.ts

@@ -35,7 +35,14 @@ import { assertEpisodeId } from "../kernel/episode-id.ts";
 import { assertLedgerV3Wire } from "./ledger-v3-validation.ts";
 
 export const LEDGER_VERSION = 3 as const;
-export const LEDGER_EVENT_KINDS = ["capability_decision", "workspace_lease", "child_lifecycle"] as const;
+export const LEDGER_EVENT_KINDS = [
+  "capability_decision",
+  "workspace_lease",
+  "child_lifecycle",
+  "cost_gate",
+  "session_config",
+  "episode_outcome",
+] as const;
 export type LedgerEventKind = (typeof LEDGER_EVENT_KINDS)[number];
 export const LEDGER_GATE_OUTCOMES = ["declined", "dismissed", "no-ui", "error"] as const;
 export type LedgerGateOutcome = (typeof LEDGER_GATE_OUTCOMES)[number];
@@ -144,6 +151,10 @@ export interface GrantRecord extends LedgerEventBase {
    * it. Absent for a `tools:`-style delegation, which has no definition.
    */
   definitionDigest?: DefinitionDigest;
+  /** SHA-256 of the complete SKILL.md used by this child. */
+  definitionHash?: string;
+  /** Installed package version exposed for the definition, when available. */
+  definitionPackageVersion?: string;
   /**
    * The context handoff this child RECEIVED (ADR-0078): the mode whose capability survived, and what crossed.
    * Absent means nothing crossed, which is the default and the overwhelming majority of records.
@@ -232,6 +243,8 @@ export function buildRecord(args: {
   humanDenied?: boolean;
   gateOutcome?: PromptOutcomeKind;
   definitionDigest?: DefinitionDigest;
+  definitionHash?: string;
+  definitionPackageVersion?: string;
   handoff?: GrantRecord["handoff"];
   /** Where the child ran (ADR-0031). Required: the probe's answer survives nowhere else. */
   executor: ExecutorKind;
@@ -255,6 +268,9 @@ export function buildRecord(args: {
   if (args.definitionDigest && !/^[a-f0-9]{64}$/i.test(args.definitionDigest.sha256)) {
     throw new TypeError("definitionDigest.sha256 must be a SHA-256 hex digest");
   }
+  if (args.definitionHash && !/^[a-f0-9]{64}$/i.test(args.definitionHash)) {
+    throw new TypeError("definitionHash must be a SHA-256 hex digest");
+  }
   // R-46: the scalar is a SUMMARY, emitted only when it cannot mislead. `buildRecord` derives it rather
   // than accepting it, so a call site cannot supply one that disagrees with the map beside it.
   const sources = args.approvalSources ?? {};
@@ -308,6 +324,8 @@ export function buildRecord(args: {
     // stops being a signal.
     ...(args.gateOutcome && args.gateOutcome !== "granted" ? { gateOutcome: args.gateOutcome } : {}),
     ...(args.definitionDigest ? { definitionDigest: args.definitionDigest } : {}),
+    ...(args.definitionHash ? { definitionHash: args.definitionHash } : {}),
+    ...(args.definitionPackageVersion ? { definitionPackageVersion: args.definitionPackageVersion } : {}),
   };
   if (args.taskDigest !== undefined) assertLedgerV3Wire(record);
   return record;
@@ -341,6 +359,10 @@ export function recordKindForEvent(event: { event?: string }): RecordKind {
       return "lifecycle";
     case "workspace_lease":
       return "lease";
+    case "cost_gate":
+    case "session_config":
+    case "episode_outcome":
+      return "fact";
     case "check_receipt": // retired kind, still imported from pre-format ledgers
       return "check";
     case "workflow_fact": // retired kind, still imported from pre-format ledgers
@@ -390,8 +412,14 @@ export {
   WORKSPACE_LEASE_OUTCOMES,
   WORKSPACE_RECOVERY_VALUES,
   buildChildLifecycleEvent,
+  buildEpisodeCostGateEvent,
+  buildEpisodeOutcomeEvent,
+  buildSessionConfigEvent,
   buildWorkspaceLeaseEvent,
   type CapabilityDecisionEvent,
+  type EpisodeCostGateEvent,
+  type EpisodeOutcomeEvent,
+  type SessionConfigEvent,
   type ChildLifecycleEvent,
   type ChildLifecycleState,
   type ChildProcessSignal,

package/src/kernel/context-handoff.ts

@@ -114,7 +114,11 @@ export function parseContextRequest(raw: unknown): { request: ContextRequest } |
     if (!Array.isArray(value.files) || value.files.some((path) => typeof path !== "string" || path.length === 0))
       return { refusal: "context.files must be an array of non-empty paths" };
     if (value.files.length > MAX_CONTEXT_FILES)
-      return { refusal: `context.files may name at most ${MAX_CONTEXT_FILES} paths` };
+      return {
+        refusal:
+          `context.files may name at most ${MAX_CONTEXT_FILES} paths; choose fewer, or omit context when the child ` +
+          "can inspect the same workspace",
+      };
     request.files = value.files as string[];
   }
   if (value.summary !== undefined) {

package/src/kernel/definitions.ts

@@ -20,6 +20,7 @@
  */
 
 import { createHash } from "node:crypto";
+import { join } from "node:path";
 import { readBoundedFile } from "./bounded-read.ts";
 import { resolveSkillResources, skillResourceName } from "./skill-resources.ts";
 import { CAPABILITY_NAMESPACE_PREFIXES } from "./capabilities.ts";
@@ -55,6 +56,10 @@ export function digestDefinition(definition: SkillDefinition): DefinitionDigest
   };
 }
 
+export function isDefinitionPackageVersion(value: unknown): value is string {
+  return typeof value === "string" && /^[0-9A-Za-z][0-9A-Za-z.+_-]{0,127}$/.test(value);
+}
+
 export interface SkillDefinition {
   /** From the path, never the frontmatter — see `parseSkillDefinition`. */
   name: string;
@@ -66,6 +71,10 @@ export interface SkillDefinition {
   /** Everything after the frontmatter — the child's system prompt. */
   body: string;
   source: string;
+  /** SHA-256 of the complete SKILL.md, matching skill-harness's raw `source_hashes["SKILL.md"]`. */
+  sourceHash?: string;
+  /** Installed package version when Pi exposes one for this definition. */
+  packageVersion?: string;
 }
 
 export interface DefinitionCeiling {
@@ -154,6 +163,7 @@ export function parseSkillDefinition(source: string, text: string): SkillDefinit
     metadata: Object.keys(metadata).length > 0 ? metadata : undefined,
     body: text.slice(match[0].length).trim(),
     source,
+    sourceHash: createHash("sha256").update(text, "utf8").digest("hex"),
   };
 }
 
@@ -224,7 +234,8 @@ export async function loadDefinitions(
   skipped?: (path: string, reason: string) => void,
 ): Promise<Map<string, SkillDefinition>> {
   const definitions = new Map<string, SkillDefinition>();
-  for (const { path } of (await resolveSkillResources(cwd)).skills) {
+  const packageVersions = new Map<string, string | undefined>();
+  for (const { path, metadata } of (await resolveSkillResources(cwd)).skills) {
     const read = await readBoundedFile(path, {
       maxBytes: DEFINITION_MAX_BYTES,
       timeoutMs: DEFINITION_READ_TIMEOUT_MS,
@@ -234,6 +245,26 @@ export async function loadDefinitions(
       continue;
     }
     const parsed = parseSkillDefinition(path, read.text);
+    if (parsed && metadata.origin === "package" && metadata.baseDir) {
+      if (!packageVersions.has(metadata.baseDir)) {
+        const manifest = await readBoundedFile(join(metadata.baseDir, "package.json"), {
+          maxBytes: DEFINITION_MAX_BYTES,
+          timeoutMs: DEFINITION_READ_TIMEOUT_MS,
+        });
+        let version: string | undefined;
+        if (manifest.ok) {
+          try {
+            const candidate = JSON.parse(manifest.text).version;
+            if (isDefinitionPackageVersion(candidate)) version = candidate;
+          } catch {
+            // A package without readable version metadata still supplies a valid definition; omit the optional stamp.
+          }
+        }
+        packageVersions.set(metadata.baseDir, version);
+      }
+      const packageVersion = packageVersions.get(metadata.baseDir);
+      if (packageVersion) parsed.packageVersion = packageVersion;
+    }
     if (!parsed) skipped?.(path, `${path} has no readable frontmatter with a description`);
     // Shadowing is legitimate — a project override is SUPPOSED to win over a package's copy — but review
     // pointed out it was the one remaining drop with no word said, in the very function being made loud.

package/src/kernel/delegate-types.ts

@@ -219,6 +219,10 @@ export interface Delegation {
    * identify — and absent on an ADR-0017 authorisation refusal, which is decided before the file is read.
    */
   definitionDigest?: DefinitionDigest;
+  /** SHA-256 of the complete SKILL.md, matching skill-harness source hashes. */
+  definitionHash?: string;
+  /** Installed package version exposed for the definition, when available. */
+  definitionPackageVersion?: string;
   /** Trusted SHA-256 of the exact model-authored task. The task text itself is never stored. */
   taskDigest: string;
   /** Non-authoritative external join metadata, snapshotted at planning time. */

package/src/kernel/delegate.ts

@@ -27,7 +27,7 @@ import {
   inheritableGrant,
   workspacePinEnv,
 } from "./propagation.ts";
-import { inheritApprovals, type InheritableApproval } from "./approval.ts";
+import { DELEGATE_SUBJECT, inheritApprovals, type InheritableApproval } from "./approval.ts";
 import { explainDoubledNamespace, suggestForUnknown, unknownCapabilities, type Catalog } from "./catalog.ts";
 import { GovernanceRefusal, refusal, type RefusalCode, type StructuredRefusal } from "./refusals.ts";
 import { contextCapability, isContextCapability, parseContextRequest, type ContextRequest } from "./context-handoff.ts";
@@ -36,7 +36,7 @@ import { resolveDelegationApproval } from "./delegation-approval.ts";
 import type { Delegation, DelegationContext, DelegationRequest } from "./delegate-types.ts";
 import { assertCapabilitiesArePropagatable } from "./capabilities.ts";
 export type { Delegation, DelegationContext, DelegationRequest } from "./delegate-types.ts";
-import { GOVERNANCE_ENV_KEYS } from "./env-names.ts";
+import { ENV_CHILD_DEFINITION, ENV_CHILD_EPISODE, ENV_CHILD_EXECUTION, GOVERNANCE_ENV_KEYS } from "./env-names.ts";
 
 export function planDelegation(request: DelegationRequest, ctx: DelegationContext): Delegation {
   const childDepth = ctx.depth + 1;
@@ -102,6 +102,8 @@ export function planDelegation(request: DelegationRequest, ctx: DelegationContex
   let requested: Capability[];
   let systemPrompt: string | undefined;
   let definitionDigest: DefinitionDigest | undefined;
+  let definitionHash: string | undefined;
+  let definitionPackageVersion: string | undefined;
   /** The definition being spawned, hoisted so the gate below can name its authorising id (ADR-0024). */
   let spawned: SkillDefinition | undefined;
 
@@ -160,7 +162,13 @@ export function planDelegation(request: DelegationRequest, ctx: DelegationContex
     // ninth return could forget, there is one, and forgetting it is not expressible. The success return
     // does not spread `empty`, so it names the field explicitly.
     definitionDigest = digestDefinition(definition);
-    Object.assign(empty, { definitionDigest });
+    definitionHash = definition.sourceHash;
+    definitionPackageVersion = definition.packageVersion;
+    Object.assign(empty, {
+      definitionDigest,
+      ...(definitionHash ? { definitionHash } : {}),
+      ...(definitionPackageVersion ? { definitionPackageVersion } : {}),
+    });
 
     const ceiling = ceilingForDefinition(definition);
     if (ceiling.undeclared) {
@@ -389,8 +397,15 @@ export function planDelegation(request: DelegationRequest, ctx: DelegationContex
   // process boundaries with no shared state.
   if (ctx.fanoutBudget !== undefined) env[ENV_FANOUT] = String(ctx.fanoutBudget);
   if (ctx.childSpawnId) env[ENV_PARENT_ID] = ctx.childSpawnId;
-  if (ctx.childExecutionId) env[ENV_EXECUTION_ID] = ctx.childExecutionId;
-  if (ctx.episodeId) env[ENV_EPISODE_ID] = ctx.episodeId;
+  if (ctx.childExecutionId) {
+    env[ENV_EXECUTION_ID] = ctx.childExecutionId;
+    env[ENV_CHILD_EXECUTION] = ctx.childExecutionId;
+  }
+  if (ctx.episodeId) {
+    env[ENV_EPISODE_ID] = ctx.episodeId;
+    env[ENV_CHILD_EPISODE] = ctx.episodeId;
+  }
+  env[ENV_CHILD_DEFINITION] = request.agent ?? DELEGATE_SUBJECT;
   if (ctx.gated.length > 0) env[ENV_GATED] = ctx.gated.join(",");
   // Approvals ride down with the grant, but only ever for what this child actually received — so
   // `approved ⊆ grant` holds at every level (ADR-0010). Written even when empty, so this object states
@@ -433,5 +448,7 @@ export function planDelegation(request: DelegationRequest, ctx: DelegationContex
     ...(correlation ? { correlation } : {}),
     ...(approvalBinding ? { approvalBinding } : {}),
     ...(definitionDigest ? { definitionDigest } : {}),
+    ...(definitionHash ? { definitionHash } : {}),
+    ...(definitionPackageVersion ? { definitionPackageVersion } : {}),
   };
 }

package/src/kernel/env-names.ts

@@ -24,6 +24,14 @@ export const ENV_FANOUT = "PI_DADDY_FANOUT";
 export const ENV_PARENT_ID = "PI_DADDY_PARENT_ID";
 export const ENV_EXECUTION_ID = "PI_DADDY_EXECUTION_ID";
 export const ENV_EPISODE_ID = "PI_DADDY_EPISODE_ID";
+export const ENV_EPISODE_COST_CEILING = "PI_DADDY_EPISODE_COST_CEILING";
+
+// Child-facing work attribution. These duplicate no authority: they let work produced outside pi-daddy carry the
+// same identities as the ledger records that governed it.
+export const ENV_CHILD_EPISODE = "PI_DADDY_EPISODE";
+export const ENV_CHILD_DEFINITION = "PI_DADDY_DEFINITION";
+export const ENV_CHILD_EXECUTION = "PI_DADDY_EXECUTION";
+export const CHILD_ATTRIBUTION_ENV_KEYS = [ENV_CHILD_EPISODE, ENV_CHILD_DEFINITION, ENV_CHILD_EXECUTION] as const;
 
 // Operator preferences a child inherits unchanged. Still governance: they decide executor, deadlines, gates.
 export const ENV_HERDR = "PI_DADDY_HERDR";
@@ -80,6 +88,8 @@ export const GOVERNANCE_ENV_KEYS: readonly string[] = Object.freeze([
   ENV_PARENT_ID,
   ENV_EXECUTION_ID,
   ENV_EPISODE_ID,
+  ENV_EPISODE_COST_CEILING,
+  ...CHILD_ATTRIBUTION_ENV_KEYS,
   ENV_HERDR,
   ENV_HERDR_WORKSPACE,
   ENV_HERDR_KEEP_PANE,

package/src/kernel/grant-env.ts

@@ -140,6 +140,8 @@ export interface ProjectSettings {
   ledger: string;
   /** Gated by default (ADR-0012): closed under subsumption, so gating tool:write also gates tool:bash. */
   gatedByDefault: Capability[];
+  /** Cumulative provider-reported USD cost at which the episode asks whether to continue. */
+  episodeCostCeiling: number;
 }
 
 export function buildProjectSettings(input: GrantEnvInput): ProjectSettings {
@@ -166,6 +168,7 @@ export function buildProjectSettings(input: GrantEnvInput): ProjectSettings {
     cautions: [...input.cautions],
     ledger: PROJECT_FILES.ledger,
     gatedByDefault: ["tool:bash"],
+    episodeCostCeiling: 5,
   };
 }
 

package/src/kernel/propagation.ts

@@ -32,6 +32,7 @@ import { WORKSPACE_WILDCARD } from "./resolve.ts";
 import { inheritApprovals, type InheritableApproval } from "./approval.ts";
 import { assertCapabilitiesArePropagatable } from "./capabilities.ts";
 import {
+  CHILD_ATTRIBUTION_ENV_KEYS,
   ENV_ADVISOR_MODEL,
   ENV_ADVISOR_TASK_EGRESS,
   ENV_ADVISOR_KEY,
@@ -41,6 +42,7 @@ import {
   ENV_PARENT_ID,
   ENV_EXECUTION_ID,
   ENV_EPISODE_ID,
+  ENV_EPISODE_COST_CEILING,
   ENV_DEPTH,
   ENV_MAX_DEPTH,
   ENV_GATED,
@@ -54,6 +56,7 @@ export {
   ENV_PARENT_ID,
   ENV_EXECUTION_ID,
   ENV_EPISODE_ID,
+  ENV_EPISODE_COST_CEILING,
   ENV_DEPTH,
   ENV_MAX_DEPTH,
   ENV_GATED,
@@ -102,6 +105,9 @@ export const GRANT_ENV_KEYS = [
   ENV_PARENT_ID,
   ENV_EXECUTION_ID,
   ENV_EPISODE_ID,
+  ENV_EPISODE_COST_CEILING,
+  // Child attribution identifies this process itself, so session publication must not clear it. `mergeChildEnv`
+  // strips it separately before applying the next child's plan.
   // ADR-0042: a child must never keep its parent's unnarrowed pin, so it is stripped like every other
   // governance value and re-supplied only by the spawn plan.
   ENV_WORKSPACE_PIN,
@@ -393,6 +399,7 @@ export function workspacePinEnv(
 export function mergeChildEnv(parentEnv: NodeJS.ProcessEnv, planEnv: Record<string, string>): NodeJS.ProcessEnv {
   const merged: NodeJS.ProcessEnv = { ...parentEnv };
   for (const key of GRANT_ENV_KEYS) delete merged[key];
+  for (const key of CHILD_ATTRIBUTION_ENV_KEYS) delete merged[key];
   return { ...merged, ...planEnv };
 }
 

package/src/products/dashboard-cli.ts

@@ -1,9 +1,9 @@
 #!/usr/bin/env node
 /**
- * `pi-daddy-dashboard` — the read-only view of one ledger or activity timeline.
+ * `pi-daddy-dashboard` — the view of one ledger or activity timeline plus session model controls.
  *
- * It reads a file and renders it; it holds no authority and connects to nothing. The Herdr pane opened by
- * `/grants dashboard` runs exactly this program with the ledger path in its environment.
+ * Ledger and cost views are read-only. When the owning pi session supplies its private endpoint, model edits are
+ * sent back to that process and use the same in-memory mutation and audit path as `/grants models`.
  */
 import { realpathSync } from "node:fs";
 import { readFile } from "node:fs/promises";
@@ -22,6 +22,7 @@ import {
   type TimelineFilter,
 } from "./activity-timeline.ts";
 import { createDashboardDisplayControls } from "./dashboard-display-controls.ts";
+import { dashboardSessionRequest, type DashboardSessionSnapshot } from "./dashboard-session-client.ts";
 import { adoptLegacyEnvironment, ENV_LEDGER, legacyEnvironmentWarning } from "../kernel/env-names.ts";
 import { projectLedgerPath } from "../kernel/project-paths.ts";
 
@@ -29,6 +30,8 @@ export const DASHBOARD_PROTOCOL_VERSION = 1 as const;
 export const ENV_DASHBOARD_LEDGER = ENV_LEDGER; // one ledger path variable for children and the dashboard (ADR-0076 PR 3b)
 export const ENV_DASHBOARD_PROTOCOL = "PI_DADDY_DASHBOARD_PROTOCOL";
 export const ENV_DASHBOARD_KEY = "PI_DADDY_DASHBOARD_KEY";
+export const ENV_DASHBOARD_SESSION_SOCKET = "PI_DADDY_DASHBOARD_SESSION_SOCKET";
+export const ENV_DASHBOARD_SESSION_TOKEN = "PI_DADDY_DASHBOARD_SESSION_TOKEN";
 export const DASHBOARD_REFRESH_MS = 250;
 
 export interface DashboardFrameOptions {
@@ -43,6 +46,7 @@ export interface DashboardFrameOptions {
   activityDetail?: { taskKey: string; field: "prompt" | "final" };
   activityAliases?: ActivityTimelineAliases;
   now?: Date;
+  session?: DashboardSessionSnapshot;
 }
 
 function shellQuote(value: string): string {
@@ -139,6 +143,8 @@ export async function dashboardFrame(options: DashboardFrameOptions): Promise<st
         width: options.width,
         details: options.details,
         history: options.history,
+        modelRows: options.session?.rows,
+        episodeCost: options.session ? { cost: options.session.cost, ceiling: options.session.ceiling } : undefined,
       });
   return waiting ? `${rendered}\n\nwaiting for ledger ${ledgerPath}` : rendered;
 }
@@ -175,6 +181,8 @@ export async function runDashboard(argv = process.argv.slice(2), env: NodeJS.Pro
   const rawProtocol = env[ENV_DASHBOARD_PROTOCOL]?.trim();
   const protocol = rawProtocol === undefined || rawProtocol === "" ? undefined : Number(rawProtocol);
   const key = env[ENV_DASHBOARD_KEY]?.trim();
+  const sessionSocket = env[ENV_DASHBOARD_SESSION_SOCKET]?.trim();
+  const sessionToken = env[ENV_DASHBOARD_SESSION_TOKEN]?.trim();
   process.title = `pi-daddy-dashboard${key ? `:${key.slice(0, 12)}` : ""}`;
 
   const display = createDashboardDisplayControls(cli.details, true);
@@ -182,6 +190,13 @@ export async function runDashboard(argv = process.argv.slice(2), env: NodeJS.Pro
   let notice = "";
   let input: ReturnType<typeof createInterface> | null = null;
   const draw = async (clear: boolean): Promise<void> => {
+    let session: DashboardSessionSnapshot | undefined;
+    if (sessionSocket && sessionToken)
+      try {
+        session = await dashboardSessionRequest(sessionSocket, sessionToken, { action: "get" });
+      } catch (error) {
+        notice ||= `session controls unavailable: ${error instanceof Error ? error.message : String(error)}`;
+      }
     const view = await dashboardFrame({
       cwd,
       ledgerPath,
@@ -190,6 +205,7 @@ export async function runDashboard(argv = process.argv.slice(2), env: NodeJS.Pro
       width: process.stdout.columns || 80,
       ...display.state,
       activityAliases: display.aliases,
+      session,
     });
     const frame = notice ? `${notice}\n\n${view}` : view;
     if (frame === previous && !clear) return;
@@ -217,8 +233,20 @@ export async function runDashboard(argv = process.argv.slice(2), env: NodeJS.Pro
     });
   };
   input.on("line", (line) => {
+    const trimmed = line.trim();
+    if (trimmed.startsWith("m ") && sessionSocket && sessionToken) {
+      void dashboardSessionRequest(sessionSocket, sessionToken, { action: "set", edits: trimmed.slice(2).trim() })
+        .then(() => {
+          notice = "session model defaults updated";
+        })
+        .catch((error) => {
+          notice = `model edit refused: ${error instanceof Error ? error.message : String(error)}`;
+        })
+        .finally(redraw);
+      return;
+    }
     // Rule 8: a line the display controls do not understand is said so, never swallowed.
-    notice = display.input(line) ? "" : `not a display command: ${JSON.stringify(line.trim())}. ${display.prompt()}`;
+    notice = display.input(line) ? "" : `not a display command: ${JSON.stringify(trimmed)}. ${display.prompt()}`;
     redraw();
   });
   const timer = setInterval(redraw, DASHBOARD_REFRESH_MS);

package/src/products/dashboard-handshake.ts

@@ -74,6 +74,7 @@ export interface DashboardHandshakeInput {
   pluginRoot: string;
   preferencePath: string;
   paneStatePath: string;
+  sessionEndpoint?: { socketPath: string; token: string };
   ui: DashboardHandshakeUI;
 }
 
@@ -101,6 +102,7 @@ export async function offerDashboardHandshake(input: DashboardHandshakeInput): P
         statePath: input.paneStatePath,
         pluginRoot: input.pluginRoot,
         allowInactive: true,
+        sessionEndpoint: input.sessionEndpoint,
       });
       input.ui.notify(`pi-daddy dashboard ${opened.kind} in pane ${opened.paneId} without changing focus.`, "info");
       return "already-installed";
@@ -152,6 +154,7 @@ export async function offerDashboardHandshake(input: DashboardHandshakeInput): P
       statePath: input.paneStatePath,
       pluginRoot: input.pluginRoot,
       allowInactive: true,
+      sessionEndpoint: input.sessionEndpoint,
     });
     input.ui.notify(`pi-daddy dashboard ${opened.kind} in pane ${opened.paneId} without changing focus.`, "info");
     return "installed";
@@ -172,6 +175,7 @@ export interface DashboardCommandInput {
   ledgerPath?: string;
   pluginRoot: string;
   paneStatePath: string;
+  sessionEndpoint?: { socketPath: string; token: string };
 }
 
 export type DashboardCommandResult =
@@ -211,6 +215,7 @@ export async function openDashboardCommand(input: DashboardCommandInput): Promis
     cwd: input.cwd,
     statePath: input.paneStatePath,
     pluginRoot: input.pluginRoot,
+    sessionEndpoint: input.sessionEndpoint,
   });
 }
 

package/src/products/dashboard-herdr.ts

@@ -6,6 +6,8 @@ import {
   ENV_DASHBOARD_KEY,
   ENV_DASHBOARD_LEDGER,
   ENV_DASHBOARD_PROTOCOL,
+  ENV_DASHBOARD_SESSION_SOCKET,
+  ENV_DASHBOARD_SESSION_TOKEN,
   DASHBOARD_PROTOCOL_VERSION,
 } from "./dashboard-cli.ts";
 import { parseReply, type HerdrExec } from "../executors/herdr-cli.ts";
@@ -291,6 +293,7 @@ export interface DashboardOpenInput {
   pluginRoot?: string;
   /** Installation handshake may open an explanatory pane before a ledger exists. */
   allowInactive?: boolean;
+  sessionEndpoint?: { socketPath: string; token: string };
 }
 export interface DashboardOpenResult {
   kind: "opened" | "reused";
@@ -308,7 +311,10 @@ export async function openOrReuseDashboard(input: DashboardOpenInput): Promise<D
   const ledgerPath = input.ledgerPath.trim() ? resolve(input.cwd, input.ledgerPath) : "";
   const cwd = resolve(input.cwd);
   const key = createHash("sha256")
-    .update(`${input.host.workspaceId}\0${input.host.tabId}\0${ledgerPath}`, "utf8")
+    .update(
+      `${input.host.workspaceId}\0${input.host.tabId}\0${ledgerPath}\0${input.sessionEndpoint?.socketPath ?? ""}`,
+      "utf8",
+    )
     .digest("hex");
   await mkdir(dirname(input.statePath), { recursive: true });
 
@@ -368,6 +374,14 @@ export async function openOrReuseDashboard(input: DashboardOpenInput): Promise<D
       "--cwd",
       cwd,
       ...(ledgerPath ? ["--env", `${ENV_DASHBOARD_LEDGER}=${ledgerPath}`] : []),
+      ...(input.sessionEndpoint
+        ? [
+            "--env",
+            `${ENV_DASHBOARD_SESSION_SOCKET}=${input.sessionEndpoint.socketPath}`,
+            "--env",
+            `${ENV_DASHBOARD_SESSION_TOKEN}=${input.sessionEndpoint.token}`,
+          ]
+        : []),
       "--env",
       `${ENV_DASHBOARD_PROTOCOL}=${DASHBOARD_PROTOCOL_VERSION}`,
       "--env",

package/src/products/dashboard-projection.ts

@@ -8,8 +8,8 @@ import {
   type LedgerV3Object as ObjectRecord,
 } from "../governance/ledger-v3-validation.ts";
 import { isLedgerCapabilityIdentifier, isLedgerDisplayIdentifier } from "../kernel/ledger-identifiers.ts";
+import { LEDGER_EVENT_KINDS } from "../governance/ledger.ts";
 import { readRecords } from "../governance/record.ts";
-import { isRetiredLedgerEvent } from "../governance/ledger-v3-validation.ts";
 
 export type DashboardState =
   "authorised" | "starting" | "running" | "completed" | "failed" | "refused" | "incomplete" | "historical";
@@ -308,13 +308,20 @@ export function parseDashboardLedger(text: string, options: DashboardProjectionO
       return;
     }
 
-    const invalid = validateV3(event);
-    if (invalid) {
-      corrupt.push({ line, reason: invalid });
+    if (event.ledgerVersion !== 3 || !nonEmpty(event.event)) {
+      corrupt.push({ line, reason: validateV3(event) ?? "invalid ledger v3 event" });
       return;
     }
-    // Written by an earlier version (check receipts, workflow facts): valid history that is not a tree node.
-    if (isRetiredLedgerEvent(event)) {
+    if (LEDGER_EVENT_KINDS.includes(event.event as (typeof LEDGER_EVENT_KINDS)[number])) {
+      const invalid = validateV3(event);
+      if (invalid) {
+        corrupt.push({ line, reason: invalid });
+        return;
+      }
+    }
+    // The dashboard renders only delegation-tree events. Other current, retired, or future additive event kinds
+    // remain valid ledger history without acquiring tree identity fields they do not have.
+    if (!["capability_decision", "child_lifecycle", "workspace_lease"].includes(event.event)) {
       orphanEvents += 1;
       return;
     }

package/src/products/dashboard-render.ts

@@ -8,6 +8,8 @@ export interface DashboardRenderOptions {
   history?: boolean;
   completedRoots?: number;
   completedChildren?: number;
+  modelRows?: Array<{ definition: string; model: string; thinking: string; source: string }>;
+  episodeCost?: { cost: number; ceiling: number };
 }
 
 const ACTIVE = new Set<DashboardState>(["authorised", "starting", "running"]);
@@ -209,6 +211,15 @@ export function renderDashboard(projection: DashboardProjection, options: Dashbo
   };
   const index = treeIndex(projection.nodes);
   const lines = [paint("PI-DADDY", 1, resolved.color), ""];
+  if (options.modelRows) {
+    lines.push(paint("SESSION MODELS", 1, resolved.color), "definition  model  thinking  source");
+    for (const row of options.modelRows)
+      lines.push(`${clean(row.definition)}  ${clean(row.model)}  ${clean(row.thinking)}  ${clean(row.source)}`);
+    lines.push("edit: m <definition> <provider:model> <thinking> | m all <provider:model> <thinking>");
+    if (options.episodeCost)
+      lines.push(`episode cost $${options.episodeCost.cost} / $${options.episodeCost.ceiling} ceiling`);
+    lines.push("");
+  }
 
   const renderRoots = (roots: DashboardNode[]): void => {
     const selected = selectedRoots(roots, index, resolved.completedRoots);

package/src/products/dashboard-session-client.ts

@@ -0,0 +1,35 @@
+import { createConnection } from "node:net";
+
+export interface DashboardSessionSnapshot {
+  rows: Array<{ definition: string; model: string; thinking: string; source: string }>;
+  cost: number;
+  ceiling: number;
+}
+
+export async function dashboardSessionRequest(
+  socketPath: string,
+  token: string,
+  request: { action: "get" } | { action: "set"; edits: string },
+): Promise<DashboardSessionSnapshot> {
+  return new Promise((resolve, reject) => {
+    const socket = createConnection(socketPath);
+    let output = "";
+    socket.setEncoding("utf8");
+    socket.setTimeout(2_000, () => socket.destroy(new Error("dashboard session request timed out")));
+    socket.once("error", reject);
+    socket.on("data", (chunk) => {
+      output += chunk;
+      if (output.length > 64 * 1024) socket.destroy(new Error("dashboard session response too large"));
+    });
+    socket.once("end", () => {
+      try {
+        const parsed = JSON.parse(output) as DashboardSessionSnapshot & { ok?: boolean; error?: string };
+        if (!parsed.ok) throw new Error(parsed.error ?? "dashboard session request failed");
+        resolve(parsed);
+      } catch (error) {
+        reject(error);
+      }
+    });
+    socket.once("connect", () => socket.write(`${JSON.stringify({ ...request, token })}\n`));
+  });
+}