@fitchmultz/pi-subagents 0.52.7 → 0.52.9

package/dist/pi-intercom/types.d.ts

@@ -6,23 +6,23 @@ export type WakeResult = {
 };
 export interface SessionInfo {
     readonly id: string;
-    readonly name?: string;
+    readonly name?: string | undefined;
     readonly cwd: string;
     readonly model: string;
     /** Opaque same-repository/worktree identity used for ambient peer awareness. */
-    readonly projectId?: string;
-    readonly rootSessionId?: string;
-    readonly parentSessionId?: string;
-    readonly incarnation?: string;
-    readonly guardedDelivery?: 1;
-    readonly applicationGuard?: string;
-    readonly status?: string;
-    readonly lastSeen?: number;
-    readonly lastIntercomActivity?: number;
-    readonly pendingAsks?: number;
-    readonly acceptsAsks?: boolean;
-    readonly subscriptions?: readonly TopicSubscription[];
-    readonly topics?: readonly TopicUpdate[];
+    readonly projectId?: string | undefined;
+    readonly rootSessionId?: string | undefined;
+    readonly parentSessionId?: string | undefined;
+    readonly incarnation?: string | undefined;
+    readonly guardedDelivery?: 1 | undefined;
+    readonly applicationGuard?: string | undefined;
+    readonly status?: string | undefined;
+    readonly lastSeen?: number | undefined;
+    readonly lastIntercomActivity?: number | undefined;
+    readonly pendingAsks?: number | undefined;
+    readonly acceptsAsks?: boolean | undefined;
+    readonly subscriptions?: readonly TopicSubscription[] | undefined;
+    readonly topics?: readonly TopicUpdate[] | undefined;
 }
 export interface TopicSubscription {
     readonly topic: string;
@@ -52,10 +52,10 @@ export interface DeliveryGuard extends ContextTarget {
 export interface PublicationReplyHint {
     readonly tool: string;
     readonly commandId: string;
-    readonly commandFingerprint?: string;
+    readonly commandFingerprint?: string | undefined;
 }
 export type SendOptions = Omit<Message, "id" | "timestamp" | "content"> & Message["content"] & {
-    readonly messageId?: string;
+    readonly messageId?: string | undefined;
 };
 export declare function isContextTarget(value: unknown): value is ContextTarget;
 export declare function isDeliveryGuard(value: unknown): value is DeliveryGuard;
@@ -69,20 +69,20 @@ export declare function isHumanMessageOrigin(value: unknown): value is HumanMess
 export interface Message {
     readonly id: string;
     readonly timestamp: number;
-    readonly replyTo?: string;
-    readonly expectsReply?: boolean;
+    readonly replyTo?: string | undefined;
+    readonly expectsReply?: boolean | undefined;
     /** Recipients verify parent ownership before elevating human origin. */
-    readonly human?: HumanMessageOrigin;
-    readonly topic?: TopicUpdate;
-    readonly delivery?: MessageDelivery;
-    readonly queueMode?: QueueMode;
-    readonly threadId?: string;
-    readonly passive?: boolean;
-    readonly guard?: DeliveryGuard;
-    readonly replyHint?: PublicationReplyHint;
+    readonly human?: HumanMessageOrigin | undefined;
+    readonly topic?: TopicUpdate | undefined;
+    readonly delivery?: MessageDelivery | undefined;
+    readonly queueMode?: QueueMode | undefined;
+    readonly threadId?: string | undefined;
+    readonly passive?: boolean | undefined;
+    readonly guard?: DeliveryGuard | undefined;
+    readonly replyHint?: PublicationReplyHint | undefined;
     readonly content: {
         readonly text: string;
-        readonly attachments?: readonly Attachment[];
+        readonly attachments?: readonly Attachment[] | undefined;
     };
 }
 export interface Attachment {
@@ -119,17 +119,17 @@ export interface SessionSnapshot {
     })[];
 }
 type CompactTopicMessage = Omit<Message, "topic"> & {
-    readonly topic?: Omit<TopicUpdate, "text"> & {
-        readonly text?: string;
-    };
+    readonly topic?: (Omit<TopicUpdate, "text"> & {
+        readonly text?: string | undefined;
+    }) | undefined;
 };
 /** Topic text and the standard coalescing key need only one copy on the wire. */
 export declare function compactTopicMessage(message: Message): CompactTopicMessage;
 export declare function normalizeMessage(value: unknown): Message | null;
 export interface LastMessageQuery {
-    readonly entryId?: string;
-    readonly offset?: number;
-    readonly limit?: number;
+    readonly entryId?: string | undefined;
+    readonly offset?: number | undefined;
+    readonly limit?: number | undefined;
 }
 export declare const LAST_MESSAGE_PAGE_LIMIT = 16384;
 export declare function isLastMessageQuery(value: unknown): value is LastMessageQuery;
@@ -152,13 +152,13 @@ export interface NativeReceipt extends ReceiptQuery {
     readonly version: 1;
     readonly sender: {
         readonly peerId: string;
-        readonly rootSessionId?: string;
-        readonly incarnation?: string;
+        readonly rootSessionId?: string | undefined;
+        readonly incarnation?: string | undefined;
     };
     readonly textSha256: string;
     readonly delivery: MessageDelivery;
-    readonly guard?: DeliveryGuard;
-    readonly replyHint?: PublicationReplyHint;
+    readonly guard?: DeliveryGuard | undefined;
+    readonly replyHint?: PublicationReplyHint | undefined;
     readonly checkpointEntryId: string;
     readonly receivedAt: number;
     /** Historical observations, not a promise that an input is still queued. */

package/dist/pi-intercom/types.js

@@ -207,16 +207,18 @@ export function compactTopicMessage(message) {
     if (!message.topic) {
         return message;
     }
+    const { threadId, ...rest } = message;
+    const dropThreadId = message.queueMode === "replace" && threadId === `topic:${message.topic.topic}`;
     return {
-        ...message,
-        topic: message.topic.text === message.content.text
-            ? { ...message.topic, text: undefined }
-            : message.topic,
-        threadId: message.queueMode === "replace" && message.threadId === `topic:${message.topic.topic}`
-            ? undefined
-            : message.threadId,
+        ...rest,
+        topic: message.topic.text === message.content.text ? withoutTopicText(message.topic) : message.topic,
+        ...(dropThreadId || threadId === undefined ? {} : { threadId }),
     };
 }
+function withoutTopicText(topic) {
+    const { text: _duplicate, ...rest } = topic;
+    return rest;
+}
 export function normalizeMessage(value) {
     if (isMessage(value)) {
         return value;

package/dist/shared/output-page.js

@@ -34,7 +34,7 @@ function utf8Bounds(bytes, count, more) {
             last--;
         }
         const lead = bytes[last];
-        if (last + width(lead) > end) {
+        if (lead === undefined || last + width(lead) > end) {
             end = last;
         }
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fitchmultz/pi-subagents",
-  "version": "0.52.7",
+  "version": "0.52.9",
   "description": "Pi extension for subagent orchestration and local session coordination",
   "license": "MIT",
   "type": "module",
@@ -63,8 +63,9 @@
     "smoke:package": "node scripts/package-smoke.mjs",
     "smoke:install": "node scripts/local-install-smoke.mjs",
     "check:size": "node scripts/measure-size.mjs",
-    "lint": "oxlint --type-aware .",
+    "lint": "oxlint --type-aware --deny-warnings .",
     "lint:fix": "oxlint --type-aware --fix .",
+    "lint:agent": "oxlint --type-aware --deny-warnings --format=agent .",
     "format": "oxfmt --write .",
     "format:check": "oxfmt --check .",
     "ci": "npm run lint && npm run format:check && npm run typecheck && npm run check:size && npm run smoke:package && npm run smoke:install && npm run test:all",
@@ -109,8 +110,8 @@
     "@earendil-works/pi-tui": "1.4.0",
     "@types/node": "24.19.2",
     "@types/sinon": "22.0.2",
-    "oxfmt": "0.74.0",
-    "oxlint": "1.89.0",
+    "oxfmt": "0.75.0",
+    "oxlint": "1.90.0",
     "oxlint-tsgolint": "7.0.2005",
     "sinon": "22.1.0",
     "type-fest": "5.10.0",

package/scripts/archive-retired-history.mjs

@@ -418,7 +418,9 @@ function main() {
       fs.readFileSync("/proc/self/status", "utf8"),
     );
     assert.ok(capability !== null, "E_PROCESS_VISIBILITY");
-    assert.ok((BigInt(`0x${capability[1]}`) & (1n << 19n)) !== 0n, "E_PROCESS_VISIBILITY");
+    const capEff = capability[1];
+    assert.ok(capEff !== undefined, "E_PROCESS_VISIBILITY");
+    assert.ok((BigInt(`0x${capEff}`) & (1n << 19n)) !== 0n, "E_PROCESS_VISIBILITY");
   }
   assert.match(values["owner-uid"] ?? "", /^(?:0|[1-9][0-9]*)$/, "E_OWNER_UID");
   const uid = Number(values["owner-uid"]);

package/src/agent/index.ts

@@ -82,17 +82,17 @@ function legacyInput(): string[] {
   }
 }
 class AgentRuntime {
-  private ctx?: ExtensionContext;
+  private ctx?: ExtensionContext | undefined;
   private readonly reporter = new BackgroundReporter(() => this.ctx);
   // A managed launcher owns children across worker replacement; otherwise this process does.
-  private host?: ManagedHost;
+  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;
+  private woken?: NodeJS.Immediate | undefined;
   // Change hints for the owner directory, legacy results and every awaited canonical file.
   private readonly watches: CompletionWatches;
   private awaited: ReadonlySet<string> = new Set();

package/src/agent/journal-tail.ts

@@ -37,7 +37,7 @@ function contentIndex(keys: readonly (string | number)[]): number | undefined {
 }
 class TextPage {
   private chars = 0;
-  private carry?: { index: number; text: string };
+  private carry?: { index: number; text: string } | undefined;
   private readonly text = new Map<number, string>();
   private readonly start: number;
   constructor(page: number) {
@@ -147,7 +147,7 @@ export class ConversationJournal {
   async page(
     entry: NativeRecord,
     page = 0,
-    options: { signal?: AbortSignal; hideThinking?: boolean } = {},
+    options: { signal?: AbortSignal | undefined; hideThinking?: boolean } = {},
   ): Promise<ConversationPage> {
     const text = new TextPage(page);
     const value = await this.native.project(

package/src/agent/launch.ts

@@ -126,7 +126,7 @@ export async function prepareLaunch(options: {
     model: selection.model.id,
     thinking: selection.thinking,
     trusted,
-    name: input.name,
+    ...(input.name !== undefined ? { name: input.name } : {}),
     createdAt: Date.now(),
   };
   // Retain even unpublished native journals on failure, including full fork evidence.

package/src/agent/notifications.ts

@@ -114,12 +114,12 @@ interface PendingJournal {
 interface Loaded {
   readonly launch: Launch;
   readonly result: Result | undefined;
-  readonly journal?: PendingJournal;
+  readonly journal?: PendingJournal | undefined;
 }
 interface Settled {
   readonly launch: string;
   readonly result: string;
-  readonly pending?: Loaded;
+  readonly pending?: Loaded | undefined;
   readonly endedAt: number;
   readonly createdAt: number;
 }
@@ -127,7 +127,7 @@ interface Completed {
   readonly id: string;
   readonly endedAt: number;
   readonly createdAt: number;
-  readonly loaded?: Loaded;
+  readonly loaded?: Loaded | undefined;
 }
 // Validated settled runs by file stamp, so polling does not reparse unchanged history.
 const settledRuns = new Map<string, Map<string, Settled>>();

package/src/agent/observation-state.ts

@@ -24,7 +24,7 @@ const WRITING = { text: "writing", thinking: "thinking", toolCall: "calling" } a
 /** A live in-flight assistant message: a transient native reference, never a receipt. */
 export interface LiveMessage {
   readonly key: number;
-  message: AssistantMessage;
+  message: AssistantMessage | undefined;
   ended: boolean;
 }
 /** A native message found in the session tree: `[seq, entry id, live message key, tool call id]`. */
@@ -77,7 +77,7 @@ export class LiveTool {
 export class LiveState {
   version = 0;
   activityVersion = 0;
-  message?: LiveMessage;
+  message?: LiveMessage | undefined;
   readonly tools = new Map<string, LiveTool>();
   readonly settlements: Settlement[] = [];
   settled = 0;

package/src/agent/observation-view.ts

@@ -206,7 +206,7 @@ export class Viewer {
   }
   private message(frame: Frame, state: LiveState): string | undefined {
     const live = state.message;
-    if (live === undefined) {
+    if (live === undefined || live.message === undefined) {
       return undefined;
     }
     const reset = this.key !== live.key;
@@ -222,18 +222,31 @@ export class Viewer {
     this.ended = live.ended;
     const limit = Math.min(content.length, BLOCKS);
     this.blocks.length = Math.min(this.blocks.length, limit);
-    for (let index = 0; index < limit && !frame.full; index++) {
-      const item = this.cursor(index, content[index]).next(index, frame, state);
-      if (item !== undefined) {
-        frame.blocks.push(item);
-      }
-    }
+    this.appendBlocks(frame, state, content, limit);
     if (!changed && frame.blocks.length === 0) {
       return undefined;
     }
     // An ended message stays live until its session entry is found and handed over.
     return `{"key":${live.key},"reset":${reset},"ended":${live.ended},"count":${content.length},"blocks":[${frame.blocks.join(",")}]}`;
   }
+  /** Refill the frame from live content blocks, reusing cursors by block identity. */
+  private appendBlocks(
+    frame: Frame,
+    state: LiveState,
+    content: readonly Block[],
+    limit: number,
+  ): void {
+    for (let index = 0; index < limit && !frame.full; index++) {
+      const block = content[index];
+      if (block === undefined) {
+        continue;
+      }
+      const item = this.cursor(index, block).next(index, frame, state);
+      if (item !== undefined) {
+        frame.blocks.push(item);
+      }
+    }
+  }
   private cursor(index: number, block: Block): BlockCursor {
     const existing = this.blocks.at(index);
     if (existing?.ref === block) {

package/src/agent/observation.ts

@@ -62,11 +62,11 @@ export class ActorObservation {
   private readonly state: LiveState;
   private readonly viewers = new Set<Viewer>();
   private readonly greeting = new Set<net.Socket>();
-  private server?: net.Server;
-  private socketPath?: string;
+  private server?: net.Server | undefined;
+  private socketPath?: string | undefined;
   private inode?: number;
-  private unsubscribe?: () => void;
-  private timer?: NodeJS.Timeout;
+  private unsubscribe?: (() => void) | undefined;
+  private timer?: NodeJS.Timeout | undefined;
   private closed = false;
   /** The actor's run is in progress, including native work before and after the agent loop. */
   private running = false;

package/src/agent/observe-card.ts

@@ -125,7 +125,7 @@ export class Card implements Component {
   ready = false;
   page = 0;
   pages = 1;
-  private cache?: { width: number; lines: string[] };
+  private cache?: { width: number; lines: string[] } | undefined;
   private arguments?: unknown;
   private phase = "";
   constructor(id: string) {
@@ -168,7 +168,9 @@ export class Card implements Component {
     this.tool.updateResult({
       content: blocks(message.content)
         .filter((part) => part.type === "text")
-        .map((part) => ({ type: "text", text: part.text })),
+        .map((part) =>
+          part.text === undefined ? { type: "text" } : { type: "text", text: part.text },
+        ),
       isError: message.isError === true,
     });
     this.tool.setExpanded(this.expanded);
@@ -221,7 +223,9 @@ export class Card implements Component {
         {
           content: blocks(result.content)
             .filter((part) => part.type === "text")
-            .map((part) => ({ type: "text", text: part.text })),
+            .map((part) =>
+              part.text === undefined ? { type: "text" } : { type: "text", text: part.text },
+            ),
           isError,
         },
         partial,

package/src/agent/observe-chrome.ts

@@ -19,7 +19,7 @@ export interface ObserverRow {
   status: string;
   live: boolean;
   createdAt: number;
-  activity?: string;
+  activity?: string | undefined;
 }
 
 export class Details extends ScrollView {
@@ -149,7 +149,7 @@ export function appendHeader(
     model: string;
     thinking: string;
     activity: string;
-    details?: Details;
+    details?: Details | undefined;
     toggle: () => void;
   },
 ): void {

package/src/agent/observe-client.ts

@@ -6,7 +6,7 @@ import { agentObservationSocketPath } from "../pi-intercom/broker/paths.ts";
 import { createMessageReader, writeFrame } from "../pi-intercom/broker/framing.ts";
 import type { ObservationIdentity } from "./observation.ts";
 import type { Launch } from "./contracts.ts";
-export type Watch = { launch: Launch; identity?: ObservationIdentity };
+export type Watch = { launch: Launch; identity?: ObservationIdentity | undefined };
 import { Assert, Type } from "./typebox.ts";
 
 const activitySchema = Type.Object({
@@ -86,8 +86,8 @@ export interface ViewedTool {
 }
 
 export class ObservationChannel {
-  current?: ObservationClient;
-  private pending?: ObservationClient;
+  current?: ObservationClient | undefined;
+  private pending?: ObservationClient | undefined;
   private readonly changed: () => void;
   constructor(changed: () => void) {
     this.changed = changed;
@@ -134,7 +134,7 @@ export class ObservationClient {
   closed = false;
   revision = 0;
   leaf?: string | null;
-  message?: { key: number; ended: boolean; blocks: ViewedBlock[] };
+  message?: { key: number; ended: boolean; blocks: ViewedBlock[] } | undefined;
   readonly tools = new Map<string, ViewedTool>();
   private readonly handovers: Array<Static<typeof settlementSchema>> = [];
   private seq = -1;
@@ -290,7 +290,7 @@ export class ObservationClient {
   }
   /** Retire live state only after its exact journal entries have been indexed. */
   settle(has: (entry: string) => boolean): boolean {
-    while (this.handovers.length > 0 && has(this.handovers[0][1])) {
+    while (this.handovers.length > 0 && has(this.handovers[0]?.[1] ?? "")) {
       const item = this.handovers.shift();
       if (item) {
         this.retire(item[2], item[3]);

package/src/agent/observe-reading.ts

@@ -10,7 +10,7 @@ export class Reading {
   following = true;
   pending = false;
   width = 0;
-  destination?: EntryAnchor;
+  destination?: EntryAnchor | undefined;
   private readonly changed: (kind: "history" | "content") => void;
   constructor(
     watch: Watch,

package/src/agent/observe-screen.ts

@@ -45,7 +45,7 @@ interface ScreenOptions {
 export class ObserverScreen extends VStack {
   private selected: string;
   private readonly list = new ChildList((id) => this.open(id));
-  private reading?: Reading;
+  private reading?: Reading | undefined;
   private readonly connection = new ObservationChannel(() => this.schedule());
   private get client(): ObservationClient | undefined {
     return this.connection.current;
@@ -53,10 +53,10 @@ export class ObserverScreen extends VStack {
   private observed = { revision: -1, status: "", signature: "" };
   private readonly saved = new Map<string, Reading>();
   private focus: "list" | "conversation" = "list";
-  private details?: Details;
+  private details?: Details | undefined;
   private failure = "";
-  private timer?: NodeJS.Timeout;
-  private indexer?: NodeJS.Immediate;
+  private timer?: NodeJS.Timeout | undefined;
+  private indexer?: NodeJS.Immediate | undefined;
   private lastFlush = -Infinity;
   private closed = false;
   private frame?: LayoutFrame;

package/src/agent/observe-transcript.ts

@@ -37,11 +37,11 @@ export class ObserverTranscript extends Container {
   private readonly cards = new Map<string, Card>();
   private readonly pages = new Map<string, PageRequest>();
   private readonly expanded = new Set<string>();
-  private before?: string;
+  private before?: string | undefined;
   private start = 0;
   private stop = 0;
   private entries: NativeRecord[] = [];
-  private selected?: string;
+  private selected?: string | undefined;
   height = 0;
   private mounted: Card[] = [];
   waiting = false;
@@ -50,8 +50,8 @@ export class ObserverTranscript extends Container {
   private readonly changed: (event: TranscriptChange) => void;
   private readonly loaded: () => void;
   private paused = false;
-  private hydration?: Promise<void>;
-  private active?: Hydration;
+  private hydration?: Promise<void> | undefined;
+  private active?: Hydration | undefined;
   private readonly jobs = new Map<string, Hydration>();
   private readonly pending = new Map<string, PageRequest>();
   version = 0;

package/src/agent/observe.ts

@@ -24,20 +24,20 @@ type Commit = (live: ReadonlyMap<string, boolean>) => void;
 type WidgetSnapshot = { status: string; rows: readonly ObserverRow[]; more: number; error: string };
 
 class Observer {
-  private ctx?: ExtensionContext;
+  private ctx?: ExtensionContext | undefined;
   private owner = "";
   private base = "";
-  private timer?: NodeJS.Timeout;
-  private scanning?: Promise<void>;
+  private timer?: NodeJS.Timeout | undefined;
+  private scanning?: Promise<void> | undefined;
   private rescan = false;
-  private close?: () => void;
-  private refresh?: () => void;
+  private close?: (() => void) | undefined;
+  private refresh?: (() => void) | undefined;
   private readonly rows = new Map<string, ObserverRow>();
   private readonly peers = new Map<string, { token: string; client: ObservationClient }>();
-  private watcher?: fs.FSWatcher;
+  private watcher?: fs.FSWatcher | undefined;
   private widgetVisible = false;
   private widgetSignature = "";
-  private widgetRender?: (snapshot: WidgetSnapshot) => void;
+  private widgetRender?: ((snapshot: WidgetSnapshot) => void) | undefined;
   private readonly launches = new Map<string, Launch>();
   private readonly finished = new Set<string>();
   private pending: string[] = [];
@@ -209,7 +209,12 @@ class Observer {
     if (this.ctx !== ctx) {
       return;
     }
-    const live = new Map(claims.map(({ root }, index) => [root, verdicts[index]]));
+    const live = new Map(
+      claims.flatMap(({ root }, index) => {
+        const verdict = verdicts[index];
+        return verdict === undefined ? [] : ([[root, verdict]] as const);
+      }),
+    );
     for (const commit of commits) {
       commit(live);
     }

package/src/agent/parking.ts

@@ -162,7 +162,7 @@ export class Parking {
   private restored?: string;
   private since = 0;
   private leaf?: string | null;
-  private shell?: string;
+  private shell?: string | undefined;
   private readonly base: string;
   private readonly launch: Launch;
   private readonly token: string;

package/src/agent/process.ts

@@ -76,7 +76,7 @@ export async function observeAlive(identities: readonly ClaimedProcess[]): Promi
  * may adopt the child meanwhile.
  */
 export class ParentCheck {
-  private current?: object;
+  private current?: object | undefined;
   /**
    * Reads the attachment synchronously, so an unreadable one still fails the caller at once.
    * Missing or released attachments detach immediately; a check in flight makes this a no-op.
@@ -97,7 +97,7 @@ export class ParentCheck {
         const [live] = await observeAlive([attachment]);
         if (
           this.current === check &&
-          !live &&
+          live !== true &&
           read(file, attachmentSchema)?.generation === attachment.generation
         ) {
           detached();
@@ -123,10 +123,11 @@ function replaced(identity: ClaimedProcess): boolean {
 }
 export function ownIdentity(pid = process.pid): Omit<ProcessIdentity, "token"> {
   // An ordinary main or managed launcher need not be a group leader. Ambiguous live PIDs fail closed.
+  const clock = readProcessClock();
   return {
     pid,
     identity: readChildProcessIdentity(pid) ?? "unverified",
-    clock: readProcessClock(),
+    ...(clock !== undefined ? { clock } : {}),
   };
 }
 export function actor(base: string, launch: Launch): OwnedProcess | undefined {
@@ -218,11 +219,12 @@ async function spawnActor(
     trySignalChildTree(child, "SIGKILL");
   });
   child.unref();
+  const clock = readProcessClock();
   write(path.join(dir, "actor.lock", "process.json"), {
     pid: child.pid,
     identity: readChildProcessIdentity(child.pid) ?? "unverified",
     token,
-    clock: readProcessClock(),
+    ...(clock !== undefined ? { clock } : {}),
   });
 }
 async function awaitStopping(

package/src/agent/runner.ts

@@ -43,8 +43,16 @@ function completionStatus(
   }
   return "completed";
 }
+/** The recorded failure: the launch error, the model's error, or the missing terminal message. */
+const failureReason = (
+  error: string | undefined,
+  message: AssistantMessage | undefined,
+): string | undefined =>
+  error ??
+  message?.errorMessage ??
+  (message ? undefined : "Native run produced no terminal assistant message.");
 class Actor {
-  private active?: Promise<void>;
+  private active?: Promise<void> | undefined;
   private stopping = false;
   private stopDeadline?: NodeJS.Timeout;
   private nextParentCheck = 0;
@@ -54,7 +62,7 @@ class Actor {
   private readonly wake = new Wake();
   // A deferred run waits for an idle session, which has no command-file event.
   private retry = false;
-  private current?: Launch;
+  private current?: Launch | undefined;
   private readonly errors: string[] = [];
   private readonly started = new Set<string>();
   // Actor-local validation metadata only; never retain command prompts or receipt authority.
@@ -96,17 +104,17 @@ class Actor {
     const message = terminal?.message;
     const accounting = this.usage(launch, baseline, terminal?.id);
     const output = this.output(message);
+    const failure = failureReason(error, message);
     const result: Result = {
       id: launch.id,
       owner: launch.owner,
       status: completionStatus(this.stopping, message, error),
       endedAt: Date.now(),
-      terminalEntryId: accounting.accountingError === undefined ? terminal?.id : undefined,
+      ...(accounting.accountingError === undefined && terminal?.id !== undefined
+        ? { terminalEntryId: terminal.id }
+        : {}),
       ...accounting,
-      error:
-        error ??
-        message?.errorMessage ??
-        (message ? undefined : "Native run produced no terminal assistant message."),
+      ...(failure !== undefined ? { error: failure } : {}),
     };
     fs.writeFileSync(path.join(runDirectory(this.base, launch.id), "output.txt"), output, {
       mode: 0o600,