@fitchmultz/pi-subagents 0.52.18 → 0.52.19

package/src/agent/index.ts

@@ -17,7 +17,14 @@ import {
   signalProcess,
 } from "./process.ts";
 import { stopChildren } from "./shutdown.ts";
-import { isChild, errorText, rememberSDK, retainsChildren } from "./host.ts";
+import {
+  isChild,
+  errorText,
+  managedHost,
+  rememberSDK,
+  retainsChildren,
+  type ManagedHost,
+} from "./host.ts";
 import { serveParked } from "./parking.ts";
 import {
   resultSchema,
@@ -54,24 +61,20 @@ import { getPiAgentDir } from "../pi-intercom/agent-dir.ts";
 import { registerCompactMessages, renderCompactResult } from "../shared/compact-cards.ts";
 import { BackgroundReporter } from "../shared/background-reporting.ts";
 
-/** Native fork lifetime owner (`ctx.managedHost`); read structurally so official Pi stays supported. */
-interface ManagedHost {
-  readonly owner: { readonly pid: number };
-  readonly ready: Promise<boolean>;
-}
-function managedHost(context: ExtensionContext): ManagedHost | undefined {
-  const host: unknown = Reflect.get(context, "managedHost");
-  if (typeof host !== "object" || host === null) {
-    return undefined;
-  }
-  const owner: unknown = Reflect.get(host, "owner");
-  const pid: unknown =
-    typeof owner === "object" && owner !== null ? Reflect.get(owner, "pid") : undefined;
-  const ready: unknown = Reflect.get(host, "ready");
-  return typeof pid === "number" && Number.isSafeInteger(pid) && ready instanceof Promise
-    ? { owner: { pid }, ready: ready.then((accepted) => accepted === true) }
-    : undefined;
+interface AttachmentBinding {
+  readonly context: ExtensionContext;
+  readonly owner: string;
+  readonly base: string;
+  readonly host: ManagedHost | undefined;
 }
+type AttachmentState =
+  | { readonly kind: "detached" }
+  | { readonly kind: "waiting"; readonly binding: AttachmentBinding }
+  | {
+      readonly kind: "attaching" | "attached";
+      readonly binding: AttachmentBinding;
+      readonly generation: string;
+    };
 
 /** Legacy results are optional; their reconciliation reports an invalid configured root. */
 function legacyInput(): string[] {
@@ -82,14 +85,8 @@ function legacyInput(): string[] {
   }
 }
 class AgentRuntime {
-  private ctx?: ExtensionContext | undefined;
+  private attachment: AttachmentState = { kind: "detached" };
   private readonly reporter = new BackgroundReporter(() => this.ctx);
-  // A managed launcher owns children across worker replacement; otherwise this process does.
-  private host?: ManagedHost | undefined;
-  private accepted = false;
-  private base = "";
-  private owner = "";
-  private generation = "";
   // Polling remains only while change hints are unavailable or a reconciliation failed.
   private timer?: NodeJS.Timeout;
   private woken?: NodeJS.Immediate | undefined;
@@ -99,7 +96,6 @@ class AgentRuntime {
   // Input stamps the last reconciliation saw; a one-second probe recovers dropped hints.
   private observed = new Map<string, string>();
   private probe?: NodeJS.Timeout;
-  private closing = false;
   private reset: Promise<void> = Promise.resolve();
   private readonly shutdown = new AbortController();
   private readonly child = isChild();
@@ -109,11 +105,28 @@ class AgentRuntime {
     this.pi = pi;
     this.watches = new CompletionWatches(this.reporter, this.wake);
   }
+  private get binding(): AttachmentBinding {
+    if (this.attachment.kind === "detached") {
+      throw new Error("Agent runtime is not attached.");
+    }
+    return this.attachment.binding;
+  }
+  private get ctx(): ExtensionContext | undefined {
+    return this.attachment.kind === "attaching" || this.attachment.kind === "attached"
+      ? this.attachment.binding.context
+      : undefined;
+  }
+  private get base(): string {
+    return this.binding.base;
+  }
+  private get owner(): string {
+    return this.binding.owner;
+  }
   private checkMain(): void {
     if (isChild()) {
       throw new Error("Only a main session may delegate or control agent runs.");
     }
-    if (this.closing || !this.ctx || this.base.length === 0) {
+    if (this.shutdown.signal.aborted || this.attachment.kind !== "attached") {
       throw new Error("Agent runtime is not attached.");
     }
   }
@@ -133,17 +146,18 @@ class AgentRuntime {
   };
   private readonly scan = (): void => {
     clearTimeout(this.timer);
-    if (this.closing || !this.ctx || this.child) {
+    if (this.shutdown.signal.aborted || this.attachment.kind !== "attached" || this.child) {
       return;
     }
+    const { context } = this.attachment.binding;
     const inputs = () => [this.base, ...legacyInput(), ...this.awaited];
     const before = new Map(inputs().map((file) => [file, pathStamp(file)]));
     let reconciled = true;
     try {
-      const { notices, awaited } = notifications(this.ctx, this.base, this.owner);
+      const { notices, awaited } = notifications(context, this.base, this.owner);
       this.awaited = awaited;
-      notices.unshift(...reconcileLegacy(this.ctx, this.reporter));
-      deliver(this.pi, this.ctx, notices);
+      notices.unshift(...reconcileLegacy(context, this.reporter));
+      deliver(this.pi, context, notices);
       this.reporter.recover("completion-scan");
     } catch (error) {
       reconciled = false;
@@ -172,23 +186,34 @@ class AgentRuntime {
     this.awaited = new Set();
   }
   private start(context: ExtensionContext): Promise<void> | undefined {
+    if (this.shutdown.signal.aborted) {
+      return;
+    }
     this.reporter.start();
-    this.host = managedHost(context);
-    if (this.host === undefined || this.accepted || this.child) {
-      this.reset = this.reset.then(() => this.attach(context));
+    const owner = context.sessionManager.getSessionId();
+    const host = managedHost(context);
+    const binding = { context, owner, base: ownerDirectory(this.agentDir, owner), host };
+    if (
+      host === undefined ||
+      this.attachment.kind === "attached" ||
+      this.attachment.kind === "attaching" ||
+      this.child
+    ) {
+      this.reset = this.reset.then(() => this.attach(binding));
       return this.reset;
     }
     // Attach and publish only after the launcher retires rollback: an unready replacement
     // must neither adopt children nor append completions to a journal it may abandon.
     // Readiness follows session_start, so never await it here.
-    this.owner = context.sessionManager.getSessionId();
-    this.base = ownerDirectory(this.agentDir, this.owner);
-    this.host.ready
-      .then(async (accepted) => {
-        if (accepted && !this.closing) {
-          this.accepted = true;
-          await this.start(context);
+    const waiting: AttachmentState = { kind: "waiting", binding };
+    this.attachment = waiting;
+    host.ready
+      .then((accepted) => {
+        if (accepted && !this.shutdown.signal.aborted && this.attachment === waiting) {
+          this.reset = this.reset.then(() => this.attach(binding));
+          return this.reset;
         }
+        return null;
       })
       .catch((error: unknown) => {
         this.reporter.report(undefined, `Agent runtime attachment: ${errorText(error)}`);
@@ -196,37 +221,36 @@ class AgentRuntime {
     return undefined;
   }
   private ownerIdentity(): Omit<ProcessIdentity, "token"> {
-    return ownIdentity(this.host?.owner.pid);
+    return ownIdentity(this.binding.host?.owner.pid);
   }
-  private async attach(context: ExtensionContext): Promise<void> {
+  private async attach(binding: AttachmentBinding): Promise<void> {
     this.unwatch();
-    this.ctx = context;
+    const attaching: AttachmentState = { kind: "attaching", binding, generation: randomUUID() };
+    this.attachment = attaching;
     if (this.child) {
+      this.attachment = { ...attaching, kind: "attached" };
       return;
     }
-    this.owner = context.sessionManager.getSessionId();
-    this.base = ownerDirectory(this.agentDir, this.owner);
-    this.generation = randomUUID();
-    await fs.promises.mkdir(this.base, { recursive: true, mode: 0o700 });
-    write(path.join(this.base, "attachment.json"), {
-      ...this.ownerIdentity(),
-      generation: this.generation,
+    await fs.promises.mkdir(binding.base, { recursive: true, mode: 0o700 });
+    write(path.join(binding.base, "attachment.json"), {
+      ...ownIdentity(binding.host?.owner.pid),
+      generation: attaching.generation,
       attached: true,
     });
-    if (this.closing) {
+    if (this.shutdown.signal.aborted) {
       return;
     }
+    this.attachment = { ...attaching, kind: "attached" };
     // Recovery and watch setup stay off the awaited startup path.
     this.timer = setTimeout(this.scan, 200).unref();
     this.probe = setInterval(this.recover, 1000).unref();
   }
   private async dispose(retain: boolean): Promise<void> {
     this.reporter.shutdown();
-    this.closing = true;
     this.unwatch();
     this.shutdown.abort();
     await this.reset;
-    if (!retain && this.base.length > 0) {
+    if (!retain && !this.child && this.attachment.kind !== "detached") {
       const file = path.join(this.base, "attachment.json");
       const attachment = read(file, attachmentSchema);
       if (attachment !== undefined && this.releases(attachment)) {
@@ -240,16 +264,20 @@ class AgentRuntime {
         );
       }
     }
-    this.ctx = undefined;
+    this.attachment = { kind: "detached" };
   }
   private releases(attachment: Attachment): boolean {
-    if (attachment.generation === this.generation) {
-      return true;
+    const state = this.attachment;
+    switch (state.kind) {
+      case "detached":
+        return false;
+      case "waiting":
+        // An unready replacement can release the launcher's existing generation on quit.
+        return attachment.attached && attachment.pid === state.binding.host?.owner.pid;
+      case "attaching":
+      case "attached":
+        return attachment.generation === state.generation;
     }
-    // An unready replacement never attached, but exiting still releases the launcher-owned children.
-    return (
-      this.generation.length === 0 && attachment.attached && attachment.pid === this.host?.owner.pid
-    );
   }
   private stop(launch: Launch) {
     const base = this.base;
@@ -433,6 +461,7 @@ class AgentRuntime {
     this.pi.on("turn_end", (event, context) => {
       // The public pending flag covers user input; the preview also includes custom messages.
       if (
+        this.attachment.kind === "attached" &&
         settle(this.owner, context.hasPendingMessages() || event.context.pendingMessages.length > 0)
       ) {
         // Released admissions may have been dropped from the queue rather than published.
@@ -459,7 +488,7 @@ class AgentRuntime {
       name: "delegate",
       label: "Delegate",
       description:
-        "Run a child on exactly this prompt; main sessions only. Fork copies the full conversation; default is fresh. Returns a receipt; completion is notified later: do other work or end the turn, don't poll.",
+        "Run a child on exactly this prompt; main sessions only. Fork copies the full conversation; default is fresh. Optional thinking overrides inherited effort for this child. Returns a receipt; completion is notified later: do other work or end the turn, don't poll.",
       parameters: delegateSchema,
       exposure: this.child ? "hidden" : "direct",
       renderResult: renderCompactResult,

package/src/agent/launch.ts

@@ -8,6 +8,16 @@ import type { DelegateInput } from "./tool-schemas.ts";
 import { loadSDK, packageRoot, runtimeEntry } from "./host.ts";
 import { runDirectory, write } from "./storage.ts";
 
+function selectedThinking(
+  requested: ThinkingLevel | undefined,
+  inherited: ThinkingLevel,
+  suffix?: ThinkingLevel,
+): ThinkingLevel {
+  if (requested !== undefined && suffix !== undefined && requested !== suffix) {
+    throw new Error("thinking conflicts with the model's thinking suffix.");
+  }
+  return suffix ?? requested ?? inherited;
+}
 function selectedModel(
   input: DelegateInput,
   context: ExtensionContext,
@@ -18,7 +28,7 @@ function selectedModel(
     if (!context.model) {
       throw new Error("No selected model; no fallback was used.");
     }
-    return { model: context.model, thinking };
+    return { model: context.model, thinking: selectedThinking(input.thinking, thinking) };
   }
   const slash = input.model.indexOf("/");
   if (slash < 1) {
@@ -29,7 +39,7 @@ function selectedModel(
     input.model.slice(slash + 1),
   );
   if (model) {
-    return { model, thinking };
+    return { model, thinking: selectedThinking(input.thinking, thinking) };
   }
   if (typeof sdk.resolveModelReference !== "function") {
     throw new Error(
@@ -49,7 +59,10 @@ function selectedModel(
   if (resolved.status !== "resolved") {
     throw new Error(`Model ${input.model} is unavailable; no fallback was used.`);
   }
-  return { model: resolved.model, thinking: resolved.thinkingLevel ?? thinking };
+  return {
+    model: resolved.model,
+    thinking: selectedThinking(input.thinking, thinking, resolved.thinkingLevel),
+  };
 }
 function targetTrust(
   sdk: Awaited<ReturnType<typeof loadSDK>>,

package/src/agent/notifications.ts

@@ -6,7 +6,7 @@ import { readOutputPage } from "../shared/output-page.ts";
 import { journalStamp } from "../shared/native-journal.ts";
 import type { Launch, Result } from "./contracts.ts";
 import { launchAt, list, runDirectory } from "./storage.ts";
-import { readCanonicalResult, readResult } from "./usage.ts";
+import { accountingState, readCanonicalResult, readResult } from "./usage.ts";
 
 function isStringSet(value: unknown): value is Set<string> {
   if (!(value instanceof Set)) {
@@ -160,7 +160,7 @@ function unchangedPending(pending: Loaded | undefined): boolean {
 function load(base: string, id: string, owner: string): Loaded {
   const launch = launchAt(base, id, owner);
   const result = readCanonicalResult(base, launch);
-  if (result?.accountingPending === undefined) {
+  if (accountingState(result).kind !== "pending") {
     return { launch, result };
   }
   // Only pending runs need this pre-read stamp to observe concurrent publication.
@@ -169,7 +169,7 @@ function load(base: string, id: string, owner: string): Loaded {
   return { launch, result: readResult(base, launch), journal };
 }
 function cacheableResult(loaded: Loaded): boolean {
-  return loaded.result?.accountingPending === undefined || loaded.journal !== undefined;
+  return accountingState(loaded.result).kind !== "pending" || loaded.journal !== undefined;
 }
 interface Scan {
   readonly base: string;
@@ -198,7 +198,7 @@ function completedRun({ base, owner, known, settled }: Scan, id: string): Comple
   const order = { endedAt: loaded.result.endedAt, createdAt: loaded.launch.createdAt };
   // Pending accounting retries on child changes, even after the completion receipt.
   // Ordinary settled history retains its launch/result-only idle probes.
-  const pending = loaded.result.accountingPending === undefined ? undefined : loaded;
+  const pending = accountingState(loaded.result).kind === "pending" ? loaded : undefined;
   if (launch !== undefined && result !== undefined && cacheableResult(loaded)) {
     settled.set(id, { launch, result, pending, ...order });
   }
@@ -216,7 +216,7 @@ function completed(base: string, owner: string, awaited: Set<string>): Completed
     const run = completedRun(scan, id);
     if (run === undefined) {
       awaited.add(path.join(runDirectory(base, id), "result.json"));
-    } else if (run.loaded?.result?.accountingPending !== undefined) {
+    } else if (run.loaded && accountingState(run.loaded.result).kind === "pending") {
       awaited.add(run.loaded.launch.sessionFile);
     }
     return run ?? [];

package/src/agent/parking.ts

@@ -29,7 +29,14 @@ import type { NativeHistory } from "../pi-intercom/last-message.ts";
 type SDK = Awaited<ReturnType<typeof loadSDK>>;
 type Restore = NonNullable<SDK["readWorkingSession"]>;
 export type Runtime = Awaited<ReturnType<SDK["createAgentSessionRuntime"]>>;
+export type ParkOutcome = "resident" | "exit-parked" | "exit-failed";
 type SessionManager = Parameters<SDK["createAgentSessionRuntime"]>[1]["sessionManager"];
+type OpenSource =
+  | { readonly kind: "journal" }
+  | { readonly kind: "parked"; readonly state: string; readonly saved: WorkingState };
+type RestorePhase =
+  | { readonly kind: "unopened" }
+  | { readonly kind: "opening" | "adopted"; readonly source: OpenSource };
 interface WorkingHold {
   readonly state: WorkingState;
   readonly sleepReady: boolean;
@@ -156,10 +163,7 @@ export function parkedState(
 }
 /** One actor generation's idle parking and exact restore; commands stay with the runner. */
 export class Parking {
-  saved?: WorkingState;
-  /** Set before entering either native open, whose effects may outlive an exception. */
-  opened = false;
-  private restored?: string;
+  private restore: RestorePhase = { kind: "unopened" };
   private since = 0;
   private leaf?: string | null;
   private shell?: string | undefined;
@@ -179,36 +183,48 @@ export class Parking {
   private get file(): string {
     return path.join(this.dir, "parked.json");
   }
+  get saved(): WorkingState | undefined {
+    return this.restore.kind !== "unopened" && this.restore.source.kind === "parked"
+      ? this.restore.source.saved
+      : undefined;
+  }
+  /** Set before entering either native open, whose effects may outlive an exception. */
+  get opened(): boolean {
+    return this.restore.kind !== "unopened";
+  }
   /** Parked authority is exact state or nothing; never a journal-only reopen. */
   open(): SessionManager {
     const { sdk, launch } = this;
     const { openWorkingSession: restore } = sdk;
     const parked = parkedState(this.dir, launch, restore && sdk.readWorkingSession);
-    this.opened = true;
+    this.restore = {
+      kind: "opening",
+      source: parked ? { kind: "parked", ...parked } : { kind: "journal" },
+    };
     if (!parked || !restore) {
       return sdk.SessionManager.open(launch.sessionFile, undefined, launch.cwd);
     }
-    this.saved = parked.saved;
-    this.restored = parked.state;
     return restore(parked.saved);
   }
   /** The ready restored generation owns this state now; a later park writes a new cut. */
   adopt(): void {
-    if (this.restored !== undefined) {
+    if (this.restore.kind !== "opening") {
+      return;
+    }
+    const { source } = this.restore;
+    if (source.kind === "parked") {
       fs.rmSync(this.file);
-      fs.rmSync(this.restored, { force: true });
+      fs.rmSync(source.state, { force: true });
     }
+    this.restore = { kind: "adopted", source };
   }
-  /** True once this generation has exited its runtime with or without parked authority. */
-  async park(runtime: Runtime, actor: Resident): Promise<boolean> {
+  /** Both exit outcomes have disposed the runtime; only one publishes parked authority. */
+  async park(runtime: Runtime, actor: Resident): Promise<ParkOutcome> {
     if (!actor.pi || !this.due(runtime.session, actor.busy) || this.hasShell()) {
-      return false;
+      return "resident";
     }
     const hold = await this.prepare(runtime, actor.pi, actor);
-    if (hold) {
-      await this.commit(runtime, hold, actor.errors);
-    }
-    return hold !== undefined;
+    return hold ? this.commit(runtime, hold, actor.errors) : "resident";
   }
   private hasShell(): boolean {
     const witness = this.shell === undefined ? undefined : shell(this.shell, this.token);
@@ -259,7 +275,11 @@ export class Parking {
     return undefined;
   }
   /** Commit: native strict exit, then capture; failure leaves no parked authority. */
-  private async commit(runtime: Runtime, hold: WorkingHold, errors: string[]): Promise<void> {
+  private async commit(
+    runtime: Runtime,
+    hold: WorkingHold,
+    errors: string[],
+  ): Promise<Exclude<ParkOutcome, "resident">> {
     const save = this.sdk.writeWorkingSession;
     if (save && finalizing(runtime)) {
       runtime.setFinalization((final) => this.capture(final, save), { strictShutdown: true });
@@ -275,7 +295,9 @@ export class Parking {
     if (read(this.file, parkedSchema)?.token !== this.token) {
       // Truthful boundary: retained input stays queued and nothing restarts implicitly.
       write(path.join(this.dir, "park-failed.json"), { token: this.token, errors });
+      return "exit-failed";
     }
+    return "exit-parked";
   }
   private async capture(
     session: AgentSession,

package/src/agent/runner.ts

@@ -8,12 +8,13 @@ import {
   type Command,
   type Launch,
   type Result,
+  type AccountingState,
 } from "./contracts.ts";
 import { launchAt, missing, read, runDirectory, write } from "./storage.ts";
 import { ownIdentity, ParentCheck, shells, signalProcess } from "./process.ts";
 import { errorText, loadSDK } from "./host.ts";
-import { Parking, type Runtime } from "./parking.ts";
-import { UsageIndex } from "./usage.ts";
+import { Parking, type ParkOutcome, type Runtime } from "./parking.ts";
+import { accountingFields, UsageIndex } from "./usage.ts";
 import { initializeCwd } from "./cwd.ts";
 import { childRuntime } from "./child-runtime.ts";
 import { ActorObservation, type ObservationStats } from "./observation.ts";
@@ -56,7 +57,7 @@ class Actor {
   private stopping = false;
   private stopDeadline?: NodeJS.Timeout;
   private nextParentCheck = 0;
-  private parking = false;
+  private parking: ParkOutcome = "resident";
   private readonly parent = new ParentCheck();
   // Raised when durable commands may need admission: change hints and stop.
   private readonly wake = new Wake();
@@ -110,10 +111,7 @@ class Actor {
       owner: launch.owner,
       status: completionStatus(this.stopping, message, error),
       endedAt: Date.now(),
-      ...(accounting.accountingError === undefined && terminal?.id !== undefined
-        ? { terminalEntryId: terminal.id }
-        : {}),
-      ...accounting,
+      ...accountingFields(accounting),
       ...(failure !== undefined ? { error: failure } : {}),
     };
     fs.writeFileSync(path.join(runDirectory(this.base, launch.id), "output.txt"), output, {
@@ -121,20 +119,21 @@ class Actor {
     });
     write(path.join(runDirectory(this.base, launch.id), "result.json"), result);
   }
-  private usage(
-    launch: Launch,
-    baseline: ReadonlySet<string>,
-    terminal?: string,
-  ): Pick<Result, "contributions" | "accountingError" | "accountingPending"> {
+  private usage(launch: Launch, baseline: ReadonlySet<string>, terminal?: string): AccountingState {
     try {
-      return { contributions: this.accounting.read(launch, baseline, terminal) };
-    } catch (error) {
       return {
-        accountingError: errorText(error),
-        ...(terminal !== undefined
-          ? { accountingPending: { terminalCandidate: terminal, baseline: [...baseline] } }
-          : {}),
+        kind: "verified",
+        contributions: this.accounting.read(launch, baseline, terminal),
+        terminalEntryId: terminal,
       };
+    } catch (error) {
+      return terminal === undefined
+        ? { kind: "unavailable", error: errorText(error), terminalEntryId: undefined }
+        : {
+            kind: "pending",
+            error: errorText(error),
+            pending: { terminalCandidate: terminal, baseline: [...baseline] },
+          };
     }
   }
   private output(message: AssistantMessage | undefined): string {
@@ -384,7 +383,7 @@ class Actor {
     } finally {
       clearInterval(watch);
     }
-    return this.parking;
+    return this.parking !== "resident";
   }
   private failure(error: unknown, unopened?: string): void {
     const launch = this.current ?? this.initial;
@@ -494,7 +493,7 @@ class Actor {
     process.off("SIGTERM", this.stop);
     process.off("SIGINT", this.stop);
     const observation: ObservationStats | undefined = this.observation?.close();
-    if (!this.parking) {
+    if (this.parking === "resident") {
       await runtime?.dispose();
     }
     if (this.stopping) {
@@ -506,7 +505,7 @@ class Actor {
       errors: this.errors,
       ...(observation === undefined ? {} : { observation }),
     });
-    if (this.parking) {
+    if (this.parking !== "resident") {
       // Parked authority requires actual exit; no leftover extension handle may keep it alive.
       process.exit();
     }

package/src/agent/tool-schemas.ts

@@ -1,6 +1,7 @@
 import type { Static } from "typebox";
 import { StringEnum } from "@earendil-works/pi-ai";
 import { Type } from "./typebox.ts";
+import { thinkingSchema } from "./contracts.ts";
 
 // Main-session tool parameters only; the detached runner must not load pi-ai values.
 export const delegateSchema = Type.Object(
@@ -15,6 +16,7 @@ export const delegateSchema = Type.Object(
           "Exact provider/model ID (:thinking and any case need host support); no fuzzy match or fallback.",
       }),
     ),
+    thinking: Type.Optional(thinkingSchema),
     context: Type.Optional(StringEnum(["fresh", "fork"] as const)),
   },
   { additionalProperties: false },

package/src/agent/usage.ts

@@ -8,12 +8,49 @@ import { Assert } from "./typebox.ts";
 import {
   contributionsSchema,
   resultSchema,
+  type AccountingState,
   type Contribution,
   type Launch,
   type Result,
 } from "./contracts.ts";
 import { read, runDirectory, write } from "./storage.ts";
 
+/** Pending repair remains authoritative until its native terminal is published and validated. */
+export function accountingState(result: Result | undefined): AccountingState {
+  if (result?.accountingPending !== undefined) {
+    return { kind: "pending", pending: result.accountingPending, error: result.accountingError };
+  }
+  const terminalEntryId = result?.terminalEntryId;
+  if (result?.contributions !== undefined) {
+    return { kind: "verified", contributions: result.contributions, terminalEntryId };
+  }
+  return result?.accountingError === undefined
+    ? { kind: "unrecorded", terminalEntryId }
+    : { kind: "unavailable", error: result.accountingError, terminalEntryId };
+}
+
+export function accountingFields(
+  state: AccountingState,
+): Pick<Result, "contributions" | "accountingPending" | "accountingError" | "terminalEntryId"> {
+  const terminal =
+    state.kind !== "pending" && state.terminalEntryId !== undefined
+      ? { terminalEntryId: state.terminalEntryId }
+      : {};
+  switch (state.kind) {
+    case "unrecorded":
+      return terminal;
+    case "verified":
+      return { contributions: state.contributions, ...terminal };
+    case "pending":
+      return {
+        accountingPending: state.pending,
+        ...(state.error === undefined ? {} : { accountingError: state.error }),
+      };
+    case "unavailable":
+      return { accountingError: state.error, ...terminal };
+  }
+}
+
 /** Billing evidence of one native entry. Missing required usage is an error only outside a baseline. */
 function billing(entry: UnknownRecord): UnknownRecord | "missing" | undefined {
   if (entry.checkpoint === true) {
@@ -171,10 +208,11 @@ export function readResult(base: string, launch: Launch): Result | undefined {
   if (!result) {
     return;
   }
-  const pending = result.accountingPending;
-  if (pending === undefined) {
+  const accounting = accountingState(result);
+  if (accounting.kind !== "pending") {
     return result;
   }
+  const { pending } = accounting;
   let contributions;
   try {
     contributions = childUsage(launch, new Set(pending.baseline), pending.terminalCandidate);
@@ -183,7 +221,14 @@ export function readResult(base: string, launch: Launch): Result | undefined {
     return result;
   }
   const { accountingPending: _pending, accountingError: _error, ...execution } = result;
-  const repaired = { ...execution, terminalEntryId: pending.terminalCandidate, contributions };
+  const repaired = {
+    ...execution,
+    ...accountingFields({
+      kind: "verified",
+      terminalEntryId: pending.terminalCandidate,
+      contributions,
+    }),
+  };
   write(path.join(runDirectory(base, launch.id), "result.json"), repaired);
   return repaired;
 }