@fitchmultz/pi-subagents 0.52.18 → 0.52.20

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;
 }

package/src/agent/view.ts

@@ -15,7 +15,7 @@ import {
 import type { RunsInput } from "./tool-schemas.ts";
 import { conversation, read, runDirectory } from "./storage.ts";
 import { published } from "./notifications.ts";
-import { readCanonicalResult, readResult } from "./usage.ts";
+import { accountingFields, accountingState, readCanonicalResult, readResult } from "./usage.ts";
 import { Type } from "./typebox.ts";
 
 const commandMetadataSchema = Type.Pick(commandSchema, ["id", "runId", "action", "createdAt"]);
@@ -72,18 +72,20 @@ function toolResult(value: unknown, text: string): ToolReply {
   return { content: [{ type: "text" as const, text }], details: value };
 }
 function receiptResult(result: Result | undefined) {
-  return result === undefined
-    ? undefined
-    : {
-        id: result.id,
-        owner: result.owner,
-        status: result.status,
-        endedAt: result.endedAt,
-        terminalEntryId: result.terminalEntryId,
-        error: result.error,
-        accountingError: result.accountingError,
-        accountingPending: result.accountingPending,
-      };
+  if (result === undefined) {
+    return;
+  }
+  const { contributions: _contributions, ...accounting } = accountingFields(
+    accountingState(result),
+  );
+  return {
+    id: result.id,
+    owner: result.owner,
+    status: result.status,
+    endedAt: result.endedAt,
+    error: result.error,
+    ...accounting,
+  };
 }
 /** `observed` holds batched liveness by actor token; any other actor gets a fresh check. */
 function processView(base: string, launch: Launch, observed?: ReadonlyMap<string, boolean>) {

package/src/agent/wake.ts

@@ -1,4 +1,5 @@
 import * as fs from "node:fs";
+import assert from "node:assert/strict";
 import { journalStamp } from "../shared/native-journal.ts";
 import { missing } from "./storage.ts";
 
@@ -21,10 +22,12 @@ export type WatchState = "unwatched" | "armed" | "changed" | "watching";
 
 /** Native change hints for one directory identity; owners still reconcile canonical files. */
 export class DirectoryWatch {
-  private watcher?: fs.FSWatcher | undefined;
-  private armed = "";
+  private state:
+    | { readonly kind: "unarmed" | "polling" }
+    | { readonly kind: "armed"; readonly watcher: fs.FSWatcher; readonly identity: string } = {
+    kind: "unarmed",
+  };
   private checked = "";
-  private failed = false;
   private readonly directory: string;
   private readonly relevant: (file: string | null) => boolean;
   private readonly wake: () => void;
@@ -38,40 +41,40 @@ export class DirectoryWatch {
     const identity = stat?.isDirectory() === true ? `${stat.dev}:${stat.ino}` : "";
     const checked = this.checked;
     this.checked = stat === undefined ? "" : `${identity}:${stat.mtimeNs}:${stat.ctimeNs}`;
-    if (this.watcher !== undefined && identity === this.armed) {
+    if (this.state.kind === "armed" && identity === this.state.identity) {
       return checked === this.checked ? "watching" : "changed";
     }
     // A replaced directory leaves an inode watch silent on Linux.
     this.close();
-    return identity === "" || this.failed ? "unwatched" : this.arm(identity);
+    return identity === "" || this.state.kind === "polling" ? "unwatched" : this.arm(identity);
   }
   private arm(identity: string): WatchState {
     try {
       const watcher = fs.watch(this.directory, { persistent: false }, (_event, file) => {
-        if (watcher === this.watcher && this.relevant(file)) {
+        if (this.state.kind === "armed" && watcher === this.state.watcher && this.relevant(file)) {
           this.wake();
         }
       });
       watcher.on("error", () => {
-        if (watcher === this.watcher) {
-          this.failed = true;
-          this.close();
+        if (this.state.kind === "armed" && watcher === this.state.watcher) {
+          watcher.close();
+          this.state = { kind: "polling" };
           this.wake();
         }
       });
-      this.watcher = watcher;
-      this.armed = identity;
+      this.state = { kind: "armed", watcher, identity };
       return "armed";
     } catch (error) {
       // Unsupported platforms and watch limits keep their owner's polling fallback.
-      this.failed = !missing(error);
+      this.state = { kind: missing(error) ? "unarmed" : "polling" };
       return "unwatched";
     }
   }
   close(): void {
-    this.watcher?.close();
-    this.watcher = undefined;
-    this.armed = "";
+    if (this.state.kind === "armed") {
+      this.state.watcher.close();
+      this.state = { kind: "unarmed" };
+    }
   }
 }
 
@@ -90,6 +93,7 @@ export class Wake {
   }
   /** Returns at once for a wake raised since the last take. */
   async sleep(ms: number): Promise<void> {
+    assert.equal(this.resolve, undefined, "A Wake belongs to one waiting owner loop.");
     if (this.raised) {
       return;
     }

package/src/pi-intercom/bridge-presence.ts

@@ -18,11 +18,15 @@ interface PresenceOwner {
   readonly restored: (identity: Identity, expires: number) => void;
 }
 
+type PresencePhase =
+  | { readonly kind: "idle" }
+  | { readonly kind: "scheduled"; readonly timer: NodeJS.Timeout }
+  | { readonly kind: "running"; readonly task: Promise<void> }
+  | { readonly kind: "stopped"; readonly task: Promise<void> };
+
 export class PersistentPresence {
   private readonly registrations = new Map<string, Registration>();
-  private stopped = false;
-  private timer?: NodeJS.Timeout;
-  private running?: Promise<void> | undefined;
+  private phase: PresencePhase = { kind: "idle" };
   private readonly owner: PresenceOwner;
 
   constructor(owner: PresenceOwner) {
@@ -88,22 +92,30 @@ export class PersistentPresence {
   }
 
   start(): void {
-    if (!this.stopped && !this.running) {
-      clearTimeout(this.timer);
-      this.timer = setTimeout(() => {
-        this.running = this.maintain().finally(() => {
-          this.running = undefined;
-          if (!this.stopped) {
-            this.timer = setTimeout(() => this.start(), 15000);
-          }
-        });
-      }, 0);
+    if (this.phase.kind === "running" || this.phase.kind === "stopped") {
+      return;
+    }
+    this.schedule(0);
+  }
+
+  private schedule(delay: number): void {
+    if (this.phase.kind === "scheduled") {
+      clearTimeout(this.phase.timer);
     }
+    const timer = setTimeout(() => {
+      const task = this.maintain().finally(() => {
+        if (this.phase.kind !== "stopped") {
+          this.schedule(15000);
+        }
+      });
+      this.phase = { kind: "running", task };
+    }, delay);
+    this.phase = { kind: "scheduled", timer };
   }
 
   private async maintain(): Promise<void> {
     for (const registration of this.registrations.values()) {
-      if (this.stopped) {
+      if (this.phase.kind === "stopped") {
         return;
       }
       const identity = this.owner.clients().get(registration.fingerprint);
@@ -125,9 +137,16 @@ export class PersistentPresence {
     }
   }
 
-  async stop(): Promise<void> {
-    this.stopped = true;
-    clearTimeout(this.timer);
-    await this.running;
+  stop(): Promise<void> {
+    const phase = this.phase;
+    if (phase.kind === "stopped") {
+      return phase.task;
+    }
+    if (phase.kind === "scheduled") {
+      clearTimeout(phase.timer);
+    }
+    const task = phase.kind === "running" ? phase.task : Promise.resolve();
+    this.phase = { kind: "stopped", task };
+    return task;
   }
 }