pi-daddy 0.41.0 → 0.43.0

package/src/executors/activity-session.ts

@@ -18,6 +18,16 @@ import { join } from "node:path";
 export interface ChildUsageObservation {
   usage?: ChildUsageTotals;
   unavailable?: "session-missing" | "session-invalid" | "usage-missing";
+  resolvedModel?: { provider: string; modelId: string };
+  effectiveThinkingLevel?: string;
+  tokenDetail?: {
+    inputTokens: number | null;
+    outputTokens: number | null;
+    cacheReadTokens: number | null;
+    cacheWriteTokens: number | null;
+    reasoningTokens: number | null;
+  };
+  compactionCount?: number;
 }
 
 export interface ActivitySession {
@@ -127,6 +137,9 @@ async function readChildUsage(path: string | Promise<string | undefined>): Promi
   let found = false;
   let reasoning = 0;
   let sawReasoning = false;
+  let resolvedModel: ChildUsageObservation["resolvedModel"];
+  let effectiveThinkingLevel: string | undefined;
+  let compactionCount = 0;
   try {
     const lines = createInterface({ input: createReadStream(resolved, { encoding: "utf8" }), crlfDelay: Infinity });
     for await (const line of lines) {
@@ -136,16 +149,37 @@ async function readChildUsage(path: string | Promise<string | undefined>): Promi
       } catch {
         return { unavailable: "session-invalid" };
       }
-      const message = object(object(entry)?.message);
+      const parsed = object(entry);
+      if (
+        parsed?.type === "model_change" &&
+        typeof parsed.provider === "string" &&
+        typeof parsed.modelId === "string"
+      ) {
+        resolvedModel = { provider: parsed.provider, modelId: parsed.modelId };
+        continue;
+      }
+      if (parsed?.type === "thinking_level_change" && typeof parsed.thinkingLevel === "string") {
+        effectiveThinkingLevel = parsed.thinkingLevel;
+        continue;
+      }
+      if (parsed?.type === "compaction") {
+        compactionCount += 1;
+        continue;
+      }
+      const message = object(parsed?.message);
       if (!message) continue;
       if (message.role === "user") {
         Object.assign(totals, emptyUsage());
         found = false;
         reasoning = 0;
         sawReasoning = false;
+        compactionCount = 0;
         continue;
       }
       if (message.role !== "assistant" && message.role !== "toolResult") continue;
+      if (message.role === "assistant" && typeof message.provider === "string" && typeof message.model === "string") {
+        resolvedModel = { provider: message.provider, modelId: message.model };
+      }
       const usage = object(message.usage);
       if (message.role === "toolResult" && !usage) continue;
       const cost = object(usage?.cost);
@@ -161,7 +195,26 @@ async function readChildUsage(path: string | Promise<string | undefined>): Promi
       }
       found = true;
     }
-    return found ? { usage: { ...totals, ...(sawReasoning ? { reasoning } : {}) } } : { unavailable: "usage-missing" };
+    if (!found)
+      return {
+        unavailable: "usage-missing",
+        ...(resolvedModel ? { resolvedModel } : {}),
+        ...(effectiveThinkingLevel ? { effectiveThinkingLevel } : {}),
+        compactionCount,
+      };
+    return {
+      usage: { ...totals, ...(sawReasoning ? { reasoning } : {}) },
+      ...(resolvedModel ? { resolvedModel } : {}),
+      ...(effectiveThinkingLevel ? { effectiveThinkingLevel } : {}),
+      tokenDetail: {
+        inputTokens: positiveOrNull(totals.input),
+        outputTokens: positiveOrNull(totals.output),
+        cacheReadTokens: positiveOrNull(totals.cacheRead),
+        cacheWriteTokens: positiveOrNull(totals.cacheWrite),
+        reasoningTokens: sawReasoning ? positiveOrNull(reasoning) : null,
+      },
+      compactionCount,
+    };
   } catch {
     return { unavailable: "session-missing" };
   }
@@ -182,3 +235,4 @@ const object = (value: unknown): Record<string, unknown> | undefined =>
   value !== null && typeof value === "object" && !Array.isArray(value) ? (value as Record<string, unknown>) : undefined;
 const nonNegative = (value: unknown): value is number =>
   typeof value === "number" && Number.isFinite(value) && value >= 0;
+const positiveOrNull = (value: number): number | null => (value > 0 ? value : null);

package/src/governance/episode-cost-gate.ts

@@ -0,0 +1,128 @@
+/** Per-episode cost threshold state shared by every child started by one session. */
+import { readFile } from "node:fs/promises";
+import { readRecords } from "./record.ts";
+
+export const DEFAULT_EPISODE_COST_CEILING = 5;
+
+export type EpisodeCostGateAnswer =
+  | { cost: number; ceiling: number; outcome: "continued"; newCeiling: number }
+  | { cost: number; ceiling: number; outcome: "stopped" };
+
+export interface EpisodeCostGateHooks {
+  warn(message: string): void;
+  pause?(): Promise<unknown> | unknown;
+  ask?(): Promise<number | null>;
+  resume?(): Promise<unknown> | unknown;
+  stop?(): Promise<unknown> | unknown;
+  gate(event: EpisodeCostGateAnswer): Promise<unknown> | unknown;
+}
+
+export function episodeCostCeilingFromSettings(value: unknown): number {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return DEFAULT_EPISODE_COST_CEILING;
+  const ceiling = (value as Record<string, unknown>).episodeCostCeiling;
+  return typeof ceiling === "number" && Number.isFinite(ceiling) && ceiling > 0
+    ? ceiling
+    : DEFAULT_EPISODE_COST_CEILING;
+}
+
+export class EpisodeCostGate {
+  #ceiling: number;
+  #costs = new Map<string, number>();
+  #warned = false;
+  #usageWarning = false;
+  #decision?: Promise<"continue" | "stop">;
+
+  constructor(ceiling: number) {
+    this.#ceiling = ceiling;
+  }
+
+  get ceiling(): number {
+    return this.#ceiling;
+  }
+
+  get cost(): number {
+    return [...this.#costs.values()].reduce((sum, value) => sum + value, 0);
+  }
+
+  setCeiling(ceiling: number): void {
+    if (Number.isFinite(ceiling) && ceiling > 0 && !this.#decision) this.#ceiling = ceiling;
+  }
+
+  seedCost(executionId: string, cost: number): void {
+    if (Number.isFinite(cost) && cost >= 0) this.#costs.set(executionId, cost);
+  }
+
+  async observe(
+    executionId: string,
+    cost: number | undefined,
+    terminal: boolean,
+    hooks: EpisodeCostGateHooks,
+  ): Promise<"continue" | "stop"> {
+    if (cost === undefined) {
+      if (terminal && !this.#usageWarning) {
+        this.#usageWarning = true;
+        hooks.warn("pi-daddy: provider reported no token usage; the episode cost gate cannot fire");
+      }
+      return "continue";
+    }
+    this.#costs.set(executionId, cost);
+    const total = [...this.#costs.values()].reduce((sum, value) => sum + value, 0);
+    if (!this.#warned && total >= this.#ceiling / 2) {
+      this.#warned = true;
+      hooks.warn(`pi-daddy: episode cost reached 50% of the $${this.#ceiling} ceiling`);
+    }
+    if (total <= this.#ceiling) return "continue";
+    if (this.#decision) {
+      const decision = await this.#decision;
+      if (decision === "stop") await hooks.stop?.();
+      return decision;
+    }
+    this.#decision = this.#decide(total, hooks);
+    return this.#decision;
+  }
+
+  async #decide(cost: number, hooks: EpisodeCostGateHooks): Promise<"continue" | "stop"> {
+    await hooks.pause?.();
+    const answer = await hooks.ask?.();
+    if (answer !== undefined && answer !== null && Number.isFinite(answer) && answer > cost) {
+      const prior = this.#ceiling;
+      this.#ceiling = answer;
+      try {
+        await hooks.gate({ cost, ceiling: prior, outcome: "continued", newCeiling: answer });
+      } catch (error) {
+        await hooks.stop?.();
+        throw error;
+      }
+      await hooks.resume?.();
+      return "continue";
+    }
+    try {
+      await hooks.gate({ cost, ceiling: this.#ceiling, outcome: "stopped" });
+    } finally {
+      await hooks.stop?.();
+    }
+    return "stop";
+  }
+}
+
+export async function loadEpisodeCosts(path: string, episodeId: string): Promise<Map<string, number>> {
+  try {
+    const parsed = readRecords(await readFile(path, "utf8"));
+    if (parsed.damage) return new Map();
+    const costs = new Map<string, number>();
+    for (const record of parsed.records) {
+      const body = record.body as Record<string, unknown>;
+      if (body?.event !== "child_lifecycle" || body.episodeId !== episodeId) continue;
+      if (body.state !== "completed" && body.state !== "failed") continue;
+      const usage = body.usage as { cost?: { total?: unknown } } | undefined;
+      const cost = usage?.cost?.total;
+      if (typeof body.executionId === "string" && typeof cost === "number" && Number.isFinite(cost) && cost >= 0) {
+        costs.set(body.executionId, cost);
+      }
+    }
+    return costs;
+  } catch (error) {
+    if ((error as NodeJS.ErrnoException).code === "ENOENT") return new Map();
+    throw error;
+  }
+}

package/src/governance/ledger-events.ts

@@ -63,6 +63,14 @@ export const CHILD_PROCESS_SIGNALS = [
 ] as const satisfies readonly NodeJS.Signals[];
 export type ChildProcessSignal = (typeof CHILD_PROCESS_SIGNALS)[number];
 
+export interface ChildTokenDetail {
+  inputTokens: number | null;
+  outputTokens: number | null;
+  cacheReadTokens: number | null;
+  cacheWriteTokens: number | null;
+  reasoningTokens: number | null;
+}
+
 export interface ChildUsageTotals {
   input: number;
   output: number;
@@ -140,10 +148,29 @@ export interface ChildLifecycleEvent extends LedgerEventBase {
   reason?: string;
   /** The inactivity bound (ms) that governed this child beside the `deadlineAt` ceiling (PR 3e). */
   idleTimeoutMs?: number;
+  /** The provider/model selected for the child, confirmed from its persisted assistant message when available. */
+  resolvedModel?: { provider: string; modelId: string } | null;
+  modelSource?: "explicit" | "session" | "definition" | "global" | "pi";
+  /** The persisted effective level and its selection source, when pi reports one. */
+  thinkingLevel?: {
+    level: string;
+    source: "explicit" | "session" | "advisor" | "definition" | "global" | "pi";
+  } | null;
+  thinkingSource?: "explicit" | "session" | "advisor" | "definition" | "global" | "pi";
+  /** Provider-reported token dimensions; zero is normalised to null rather than invented as reported usage. */
+  tokenDetail?: ChildTokenDetail;
   /** Aggregate model usage read from the child's pi session file after it stopped. */
   usage?: ChildUsageTotals;
+  /** Number of compaction entries in the child's current turn, when the session file was readable. */
+  compactionCount?: number;
   /** Why totals could not be read; a fixed code, never transcript content. */
   usageUnavailable?: "session-missing" | "session-invalid" | "usage-missing";
+  /** Child-facing identity variables exported at the process boundary. */
+  exportedEnvironment?: string[];
+  /** SHA-256 of the complete SKILL.md used by this child. */
+  definitionHash?: string;
+  /** Installed package version exposed for the definition, when available. */
+  definitionPackageVersion?: string;
 }
 
 export type CapabilityDecisionEvent = GrantRecord & {
@@ -154,7 +181,120 @@ export type CapabilityDecisionEvent = GrantRecord & {
   taskDigest: string;
 };
 
-export type RuntimeLedgerEvent = CapabilityDecisionEvent | WorkspaceLeaseEvent | ChildLifecycleEvent;
+export interface EpisodeOutcomeEvent extends Omit<LedgerEventBase, "correlation"> {
+  ledgerVersion: typeof LEDGER_VERSION;
+  event: "episode_outcome";
+  episodeId: string;
+  commit: string;
+  survived: boolean;
+  ci: "green" | "red" | "none";
+  amended: boolean;
+  corrected: boolean;
+  label: "positive" | "negative" | "unknown";
+}
+
+export interface EpisodeCostGateEvent extends Omit<LedgerEventBase, "episodeId" | "correlation"> {
+  ledgerVersion: typeof LEDGER_VERSION;
+  event: "cost_gate";
+  episodeId: string;
+  executionId: string;
+  parentExecutionId: string | null;
+  childId: string;
+  gate: "episode_cost";
+  cost: number;
+  ceiling: number;
+  outcome: "continued" | "stopped";
+  newCeiling?: number;
+}
+
+export interface SessionConfigEvent extends Omit<LedgerEventBase, "correlation"> {
+  ledgerVersion: typeof LEDGER_VERSION;
+  event: "session_config";
+  episodeId: string;
+  outcome: "kept" | "changed";
+  trigger: "first-delegation" | "grants-models";
+  overrides: Record<string, { model: string; thinking: string }>;
+}
+
+export type RuntimeLedgerEvent =
+  | CapabilityDecisionEvent
+  | WorkspaceLeaseEvent
+  | ChildLifecycleEvent
+  | EpisodeCostGateEvent
+  | SessionConfigEvent
+  | EpisodeOutcomeEvent;
+
+export function buildSessionConfigEvent(args: {
+  episodeId: string;
+  outcome: "kept" | "changed";
+  trigger: "first-delegation" | "grants-models";
+  overrides: ReadonlyMap<string, { model?: string; thinking?: string }>;
+  now: Date;
+}): SessionConfigEvent {
+  return assertLedgerV3Wire({
+    ledgerVersion: LEDGER_VERSION,
+    event: "session_config",
+    ts: args.now.toISOString(),
+    episodeId: args.episodeId,
+    outcome: args.outcome,
+    trigger: args.trigger,
+    overrides: Object.fromEntries(
+      [...args.overrides].map(([name, value]) => [name, { model: value.model!, thinking: value.thinking! }]),
+    ),
+  });
+}
+
+export function buildEpisodeOutcomeEvent(args: {
+  episodeId: string;
+  commit: string;
+  survived: boolean;
+  ci: "green" | "red" | "none";
+  amended: boolean;
+  corrected: boolean;
+  label: "positive" | "negative" | "unknown";
+  now: Date;
+}): EpisodeOutcomeEvent {
+  return assertLedgerV3Wire({
+    ledgerVersion: LEDGER_VERSION,
+    event: "episode_outcome",
+    ts: args.now.toISOString(),
+    episodeId: args.episodeId,
+    commit: args.commit,
+    survived: args.survived,
+    ci: args.ci,
+    amended: args.amended,
+    corrected: args.corrected,
+    label: args.label,
+  });
+}
+
+export function buildEpisodeCostGateEvent(args: {
+  episodeId: string;
+  executionId: string;
+  parentExecutionId: string | null;
+  childId: string;
+  cost: number;
+  ceiling: number;
+  outcome: "continued" | "stopped";
+  newCeiling?: number;
+  now: Date;
+}): EpisodeCostGateEvent {
+  assertEventIdentity(args);
+  return assertLedgerV3Wire({
+    ledgerVersion: LEDGER_VERSION,
+    event: "cost_gate",
+    ts: args.now.toISOString(),
+    episodeId: args.episodeId,
+    executionId: args.executionId,
+    parentExecutionId: args.parentExecutionId,
+    childId: args.childId,
+    gate: "episode_cost",
+    cost: args.cost,
+    ceiling: args.ceiling,
+    outcome: args.outcome,
+    ...(args.newCeiling !== undefined ? { newCeiling: args.newCeiling } : {}),
+  });
+}
 
 export function buildWorkspaceLeaseEvent(args: {
   episodeId?: string;
@@ -212,12 +352,24 @@ export function buildChildLifecycleEvent(args: {
   aborted?: boolean;
   truncated?: boolean;
   reason?: string;
+  resolvedModel?: { provider: string; modelId: string };
+  modelSource?: "explicit" | "session" | "definition" | "global" | "pi";
+  effectiveThinkingLevel?: string;
+  thinkingSource?: "explicit" | "session" | "advisor" | "definition" | "global" | "pi";
+  tokenDetail?: ChildTokenDetail;
   usage?: ChildUsageTotals;
+  compactionCount?: number;
   usageUnavailable?: "session-missing" | "session-invalid" | "usage-missing";
+  exportedEnvironment?: readonly string[];
+  definitionHash?: string;
+  definitionPackageVersion?: string;
   correlation?: CorrelationMetadata;
   now: Date;
 }): ChildLifecycleEvent {
   assertEventIdentity(args);
+  if (args.definitionHash && !/^[a-f0-9]{64}$/i.test(args.definitionHash)) {
+    throw new TypeError("definitionHash must be a SHA-256 hex digest");
+  }
   return assertLedgerV3Wire({
     ledgerVersion: LEDGER_VERSION,
     event: "child_lifecycle",
@@ -238,8 +390,28 @@ export function buildChildLifecycleEvent(args: {
     ...(args.aborted ? { aborted: true } : {}),
     ...(args.truncated ? { truncated: true } : {}),
     ...(args.reason ? { reason: args.reason } : {}),
+    resolvedModel: args.resolvedModel ? structuredClone(args.resolvedModel) : null,
+    ...(args.modelSource ? { modelSource: args.modelSource } : {}),
+    thinkingLevel:
+      args.effectiveThinkingLevel && args.thinkingSource
+        ? { level: args.effectiveThinkingLevel, source: args.thinkingSource }
+        : null,
+    ...(args.thinkingSource ? { thinkingSource: args.thinkingSource } : {}),
+    tokenDetail: args.tokenDetail
+      ? structuredClone(args.tokenDetail)
+      : {
+          inputTokens: null,
+          outputTokens: null,
+          cacheReadTokens: null,
+          cacheWriteTokens: null,
+          reasoningTokens: null,
+        },
     ...(args.usage ? { usage: structuredClone(args.usage) } : {}),
+    ...(args.compactionCount !== undefined ? { compactionCount: args.compactionCount } : {}),
     ...(args.usageUnavailable ? { usageUnavailable: args.usageUnavailable } : {}),
+    ...(args.exportedEnvironment ? { exportedEnvironment: [...args.exportedEnvironment] } : {}),
+    ...(args.definitionHash ? { definitionHash: args.definitionHash } : {}),
+    ...(args.definitionPackageVersion ? { definitionPackageVersion: args.definitionPackageVersion } : {}),
     ...(args.correlation ? { correlation: structuredClone(args.correlation) } : {}),
   });
 }

package/src/governance/ledger-v3-validation.ts

@@ -3,6 +3,8 @@ import { isExecutionId } from "../kernel/execution-id.ts";
 import { isEpisodeId } from "../kernel/episode-id.ts";
 import { REFUSAL_CODES } from "../kernel/refusals.ts";
 import { isLedgerCapabilityIdentifier, isLedgerDisplayIdentifier } from "../kernel/ledger-identifiers.ts";
+import { CHILD_ATTRIBUTION_ENV_KEYS } from "../kernel/env-names.ts";
+import { isDefinitionPackageVersion } from "../kernel/definitions.ts";
 
 export type LedgerV3Object = Record<string, unknown>;
 
@@ -103,6 +105,8 @@ const FIELDS = {
     "humanDenied",
     "gateOutcome",
     "definitionDigest",
+    "definitionHash",
+    "definitionPackageVersion",
     "handoff",
     "executor",
     "taskFrom",
@@ -128,6 +132,33 @@ const FIELDS = {
     "refusal",
     "correlation",
   ]),
+  cost_gate: new Set([
+    "ledgerVersion",
+    "event",
+    "ts",
+    "episodeId",
+    "executionId",
+    "parentExecutionId",
+    "childId",
+    "gate",
+    "cost",
+    "ceiling",
+    "outcome",
+    "newCeiling",
+  ]),
+  session_config: new Set(["ledgerVersion", "event", "ts", "episodeId", "outcome", "trigger", "overrides"]),
+  episode_outcome: new Set([
+    "ledgerVersion",
+    "event",
+    "ts",
+    "episodeId",
+    "commit",
+    "survived",
+    "ci",
+    "amended",
+    "corrected",
+    "label",
+  ]),
   child_lifecycle: new Set([
     "ledgerVersion",
     "event",
@@ -146,8 +177,17 @@ const FIELDS = {
     "reason",
     "deadlineAt",
     "idleTimeoutMs",
+    "resolvedModel",
+    "modelSource",
+    "thinkingLevel",
+    "thinkingSource",
+    "tokenDetail",
     "usage",
+    "compactionCount",
     "usageUnavailable",
+    "exportedEnvironment",
+    "definitionHash",
+    "definitionPackageVersion",
     "herdrPaneId",
     "herdrAgentName",
     "correlation",
@@ -297,6 +337,8 @@ function validateCapabilityDecision(event: LedgerV3Object): string | null {
     !optional(event, "humanDenied", (value) => value === true) ||
     !optional(event, "gateOutcome", (value) => GATE_OUTCOMES.has(String(value))) ||
     !optional(event, "definitionDigest", validDefinitionDigest) ||
+    !optional(event, "definitionHash", (value) => SHA256_RE.test(String(value))) ||
+    !optional(event, "definitionPackageVersion", isDefinitionPackageVersion) ||
     !optional(event, "taskFrom", isLedgerDisplayIdentifier) ||
     !optional(event, "taskFromExecutionId", isExecutionId) ||
     !optional(event, "correlation", validCorrelation) ||
@@ -354,6 +396,81 @@ function validUsage(value: unknown): boolean {
   );
 }
 
+function validResolvedModel(value: unknown): boolean {
+  return (
+    value === null ||
+    (isLedgerObject(value) &&
+      Object.keys(value).every((key) => ["provider", "modelId"].includes(key)) &&
+      isNonEmptyString(value.provider) &&
+      isNonEmptyString(value.modelId))
+  );
+}
+
+const MODEL_SOURCES = ["explicit", "session", "definition", "global", "pi"];
+const THINKING_SOURCES = [...MODEL_SOURCES, "advisor"];
+function validThinkingLevel(value: unknown): boolean {
+  return (
+    value === null ||
+    (isLedgerObject(value) &&
+      Object.keys(value).every((key) => ["level", "source"].includes(key)) &&
+      isNonEmptyString(value.level) &&
+      THINKING_SOURCES.includes(String(value.source)))
+  );
+}
+
+function validTokenDetail(value: unknown): boolean {
+  if (!isLedgerObject(value)) return false;
+  const fields = ["inputTokens", "outputTokens", "cacheReadTokens", "cacheWriteTokens", "reasoningTokens"];
+  return (
+    Object.keys(value).length === fields.length &&
+    fields.every((field) => value[field] === null || (nonNegativeNumber(value[field]) && (value[field] as number) > 0))
+  );
+}
+
+function validExportedEnvironment(value: unknown): boolean {
+  return (
+    Array.isArray(value) &&
+    value.length === CHILD_ATTRIBUTION_ENV_KEYS.length &&
+    CHILD_ATTRIBUTION_ENV_KEYS.every((name) => value.filter((entry) => entry === name).length === 1)
+  );
+}
+
+function validateCostGate(event: LedgerV3Object): string | null {
+  if (
+    event.gate !== "episode_cost" ||
+    !nonNegativeNumber(event.cost) ||
+    !nonNegativeNumber(event.ceiling) ||
+    (event.ceiling as number) <= 0 ||
+    !["continued", "stopped"].includes(String(event.outcome))
+  ) {
+    return "cost gate required fields are invalid";
+  }
+  if (
+    !optional(event, "newCeiling", (value) => nonNegativeNumber(value) && (value as number) > (event.cost as number))
+  ) {
+    return "cost gate new ceiling is invalid";
+  }
+  if ((event.outcome === "continued") !== Object.hasOwn(event, "newCeiling")) {
+    return "continued cost gate requires exactly one new ceiling";
+  }
+  return null;
+}
+
+function validateEpisodeOutcome(event: LedgerV3Object): string | null {
+  if (
+    !isTimestamp(event.ts) ||
+    !isEpisodeId(event.episodeId) ||
+    !/^[a-f0-9]{40}$/i.test(String(event.commit)) ||
+    typeof event.survived !== "boolean" ||
+    !["green", "red", "none"].includes(String(event.ci)) ||
+    typeof event.amended !== "boolean" ||
+    typeof event.corrected !== "boolean" ||
+    !["positive", "negative", "unknown"].includes(String(event.label))
+  )
+    return "episode outcome fields are invalid";
+  return null;
+}
+
 function validateChildLifecycle(event: LedgerV3Object): string | null {
   if (
     !["starting", "running", "completed", "failed"].includes(String(event.state)) ||
@@ -373,10 +490,19 @@ function validateChildLifecycle(event: LedgerV3Object): string | null {
     !optional(event, "aborted", (value) => value === true) ||
     !optional(event, "truncated", (value) => value === true) ||
     !optional(event, "reason", (value) => typeof value === "string") ||
+    !optional(event, "resolvedModel", validResolvedModel) ||
+    !optional(event, "modelSource", (value) => MODEL_SOURCES.includes(String(value))) ||
+    !optional(event, "thinkingLevel", validThinkingLevel) ||
+    !optional(event, "thinkingSource", (value) => THINKING_SOURCES.includes(String(value))) ||
+    !optional(event, "tokenDetail", validTokenDetail) ||
     !optional(event, "usage", validUsage) ||
+    !optional(event, "compactionCount", (value) => Number.isInteger(value) && (value as number) >= 0) ||
     !optional(event, "usageUnavailable", (value) =>
       ["session-missing", "session-invalid", "usage-missing"].includes(String(value)),
     ) ||
+    !optional(event, "exportedEnvironment", validExportedEnvironment) ||
+    !optional(event, "definitionHash", (value) => SHA256_RE.test(String(value))) ||
+    !optional(event, "definitionPackageVersion", isDefinitionPackageVersion) ||
     !optional(event, "correlation", validCorrelation)
   ) {
     return "child lifecycle optional fields are invalid";
@@ -407,10 +533,30 @@ export function validateLedgerV3Event(event: LedgerV3Object): string | null {
   if (typeof kind !== "string" || !Object.hasOwn(FIELDS, kind)) return "unknown ledger event discriminator";
   const allowed = FIELDS[kind as EventKind];
   if (Object.keys(event).some((field) => !allowed.has(field))) return "ledger v3 contains an unsupported field";
+  if (kind === "session_config") {
+    if (
+      !isEpisodeId(event.episodeId) ||
+      !["kept", "changed"].includes(String(event.outcome)) ||
+      !["first-delegation", "grants-models"].includes(String(event.trigger)) ||
+      !isLedgerObject(event.overrides) ||
+      !Object.entries(event.overrides).every(
+        ([name, value]) =>
+          isNonEmptyString(name) &&
+          isLedgerObject(value) &&
+          Object.keys(value).length === 2 &&
+          isNonEmptyString(value.model) &&
+          isNonEmptyString(value.thinking),
+      )
+    )
+      return "session config fields are invalid";
+    return null;
+  }
+  if (kind === "episode_outcome") return validateEpisodeOutcome(event);
   const base = validateBase(event);
   if (base) return base;
   if (kind === "capability_decision") return validateCapabilityDecision(event);
   if (kind === "workspace_lease") return validateWorkspaceLease(event);
+  if (kind === "cost_gate") return validateCostGate(event);
   return validateChildLifecycle(event);
 }