@fitchmultz/pi-subagents 0.52.7 → 0.52.9

package/src/agent/saved.ts

@@ -47,10 +47,20 @@ function ownedRun(context: ExtensionContext, id: string) {
     throw new Error("Legacy continuation requires a published native owner.");
   }
   const journal = new NativeJournal(file, "live");
-  if (journal.records[0].value.id !== context.sessionManager.getSessionId()) {
+  const [opening] = journal.records;
+  if (opening === undefined || opening.value.id !== context.sessionManager.getSessionId()) {
     throw new Error("Native owner journal identity changed; nothing was launched.");
   }
-  let owned;
+  const owned = findOwnedRun(journal, id);
+  if (owned?.ownerSessionId !== context.sessionManager.getSessionId()) {
+    throw new Error("Missing saved native owner or foreign legacy run; nothing was launched.");
+  }
+  Assert(singleSchema, owned);
+  return owned;
+}
+/** The most recent saved subagent-run record for this run id, if one exists. */
+function findOwnedRun(journal: NativeJournal, id: string): Record<string, unknown> | undefined {
+  let owned: Record<string, unknown> | undefined;
   for (const record of journal.records) {
     if (record.value.type === "custom" && record.value.customType === "subagent-run") {
       const { data } = journal.body(record);
@@ -59,10 +69,6 @@ function ownedRun(context: ExtensionContext, id: string) {
       }
     }
   }
-  if (owned?.ownerSessionId !== context.sessionManager.getSessionId()) {
-    throw new Error("Missing saved native owner or foreign legacy run; nothing was launched.");
-  }
-  Assert(singleSchema, owned);
   return owned;
 }
 function requireExited(pid: unknown): void {
@@ -101,7 +107,11 @@ function nativeSession(contract: Contract) {
     throw new Error("Legacy continuation requires the exact saved native journal.");
   }
   const journal = new NativeJournal(contract.sessionFile, "live");
-  const sessionId = journal.body(journal.records[0]).id;
+  const [opening] = journal.records;
+  if (opening === undefined) {
+    throw new Error("Not a readable native Pi session.");
+  }
+  const sessionId = journal.body(opening).id;
   if (
     typeof sessionId !== "string" ||
     sessionId.length === 0 ||

package/src/agent/usage.ts

@@ -74,7 +74,7 @@ function reusable(cached: Prefix | undefined, stat: fs.BigIntStats): Prefix {
  * accepted LF boundary. Baselines, required usage and attribution apply to each read.
  */
 export class UsageIndex {
-  private prefix?: Prefix;
+  private prefix?: Prefix | undefined;
   read(launch: Launch, baseline: ReadonlySet<string>, terminal?: string): Contribution[] {
     const values: unknown[] = [];
     const reachedTerminal = new Error("Native terminal boundary reached.");

package/src/agent/view.ts

@@ -36,8 +36,8 @@ interface RunSummary {
   id: string;
   owner: string;
   rootId: string;
-  predecessor?: string;
-  name?: string;
+  predecessor?: string | undefined;
+  name?: string | undefined;
   cwd: string;
   model: string;
   thinking: string;
@@ -45,24 +45,28 @@ interface RunSummary {
   admission: string;
   status: string;
   completed: boolean;
-  result?: Pick<Result, "status" | "endedAt" | "error">;
+  result?: Pick<Result, "status" | "endedAt" | "error"> | undefined;
   nativeReceipt: string | null;
   process: ReturnType<typeof processView>;
-  lastWakeFailure?: { at: number; reason: string };
+  lastWakeFailure?: { at: number; reason: string } | undefined;
   sessionId: string;
   sessionFile: string;
   outputFile: string;
   guidance: Guidance[];
 }
 interface RunView extends Omit<RunSummary, "result"> {
-  result?: Result;
+  result?: Result | undefined;
   output: ReturnType<typeof outputView>;
 }
 type Receipt =
   | { readonly receipt: "launch"; readonly note: string }
   | { readonly receipt: "continuation" | "existing-successor" }
   | { readonly receipt: "guidance"; readonly command: string; readonly note: string }
-  | { readonly stopRequest?: string; readonly stopAcknowledged: false; readonly note: string };
+  | {
+      readonly stopRequest?: string | undefined;
+      readonly stopAcknowledged: false;
+      readonly note: string;
+    };
 
 function toolResult(value: unknown, text: string): ToolReply {
   return { content: [{ type: "text" as const, text }], details: value };
@@ -144,7 +148,7 @@ function metadata(
   launch: Launch,
   result: Result | undefined,
   options: {
-    ctx?: ExtensionContext;
+    ctx?: ExtensionContext | undefined;
     guidance: Guidance[];
     observed?: ReadonlyMap<string, boolean>;
   },
@@ -197,7 +201,12 @@ async function summaries(
     ...new Map(launches.map((launch) => [launch.rootId, actor(base, launch)])).values(),
   ].filter((identity) => identity !== undefined);
   const verdicts = await observeAlive(identities);
-  const observed = new Map(identities.map((identity, index) => [identity.token, verdicts[index]]));
+  const observed = new Map(
+    identities.flatMap((identity, index) => {
+      const verdict = verdicts[index];
+      return verdict === undefined ? [] : ([[identity.token, verdict]] as const);
+    }),
+  );
   return launches.map((launch) => {
     const view = metadata(base, launch, readCanonicalResult(base, launch), {
       ctx,
@@ -211,7 +220,7 @@ async function summaries(
         ? {
             status: view.result.status,
             endedAt: view.result.endedAt,
-            error: view.result.error?.slice(0, 2048),
+            ...(view.result.error !== undefined ? { error: view.result.error.slice(0, 2048) } : {}),
           }
         : undefined,
     };

package/src/agent/wake.ts

@@ -21,7 +21,7 @@ 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;
+  private watcher?: fs.FSWatcher | undefined;
   private armed = "";
   private checked = "";
   private failed = false;
@@ -78,7 +78,7 @@ export class DirectoryWatch {
 /** A coalesced wake for one owner loop; raised until that loop takes it. */
 export class Wake {
   private raised = true;
-  private resolve?: () => void;
+  private resolve?: (() => void) | undefined;
   readonly raise = (): void => {
     this.raised = true;
     this.resolve?.();

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

@@ -39,10 +39,10 @@ export interface Identity {
   readonly fingerprint256: string;
   readonly name: string;
   readonly cwd: string;
-  readonly wake?: WakePolicy;
+  readonly wake?: WakePolicy | undefined;
 }
 export interface Config {
-  readonly stateDir?: string;
+  readonly stateDir?: string | undefined;
   readonly port: number;
   readonly ca: string;
   readonly cert: string;

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

@@ -76,7 +76,7 @@ function decode(value: unknown): Envelope {
 
 /** Persistent payloads leave only ID tombstones after acknowledgement, preventing replay resurrection. */
 export class Mailbox {
-  private readonly db?: DatabaseSync;
+  private readonly db?: DatabaseSync | undefined;
   private readonly entries = new Map<string, Entry>();
   private bytes = 0;
   private sequence = 0;

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

@@ -22,7 +22,7 @@ export class PersistentPresence {
   private readonly registrations = new Map<string, Registration>();
   private stopped = false;
   private timer?: NodeJS.Timeout;
-  private running?: Promise<void>;
+  private running?: Promise<void> | undefined;
   private readonly owner: PresenceOwner;
 
   constructor(owner: PresenceOwner) {

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

@@ -16,10 +16,10 @@ export type Operation =
       readonly route: "POST /v1/send";
       readonly to: string;
       readonly message: string;
-      readonly passive?: boolean;
-      readonly messageId?: string;
-      readonly replyTo?: string;
-      readonly expectsReply?: boolean;
+      readonly passive?: boolean | undefined;
+      readonly messageId?: string | undefined;
+      readonly replyTo?: string | undefined;
+      readonly expectsReply?: boolean | undefined;
     };
 type Route = Operation["route"];
 const fields = {
@@ -39,7 +39,7 @@ export function routeFor(req: IncomingMessage): Route {
   ) {
     throw new Fault(403, "browser_forbidden", "Browser access is not supported.");
   }
-  const route = `${req.method ?? ""} ${(req.url ?? "").split("?")[0]}`;
+  const route = `${req.method ?? ""} ${(req.url ?? "").split("?")[0] ?? ""}`;
   if (!isRoute(route)) {
     throw new Fault(404, "not_found", "Unknown method or path.");
   }

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

@@ -16,12 +16,12 @@ const SEND_TIMEOUT = 8000;
 const LIST_TIMEOUT = 5000;
 
 interface SendOptions extends Pick<Message, "replyTo" | "expectsReply" | "delivery"> {
-  readonly messageId?: string;
+  readonly messageId?: string | undefined;
 }
 export interface SessionOwner {
-  readonly stateDir?: string;
-  readonly notifications?: boolean;
-  readonly mailboxChanged?: () => void;
+  readonly stateDir?: string | undefined;
+  readonly notifications?: boolean | undefined;
+  readonly mailboxChanged?: (() => void) | undefined;
   readonly allowed: (identity: Identity) => boolean;
   readonly lost: (fp: string, count?: number) => void;
   readonly retired: (fp: string, generation: string) => void;
@@ -42,7 +42,7 @@ export class Session {
   private inboxChanged = new AbortController();
   private closed = false;
   private connecting?: Promise<void>;
-  private disconnecting?: Promise<void>;
+  private disconnecting?: Promise<void> | undefined;
   private retirement?: Promise<void>;
   private lease?: NodeJS.Timeout;
   private closeReason: Fault = new Fault(503, "broker_unavailable", "Broker connection failed.");

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

@@ -35,12 +35,12 @@ function bucket(identity: Identity): string {
 /** Mailbox commits and durable retry/quota deadlines drive wakes; there is no intake scan timer. */
 export class WakeDeliveries {
   private readonly stateDir: string | undefined;
-  private readonly state?: WakeState;
+  private readonly state?: WakeState | undefined;
   private readonly allowed: (identity: Identity) => boolean;
   private readonly deliveries = new Map<string, Delivery>();
   private readonly controller = new AbortController();
   private timer?: NodeJS.Timeout;
-  private running?: Promise<void>;
+  private running?: Promise<void> | undefined;
   private dirty = false;
   private storageBackoff = 15000;
 

package/src/pi-intercom/bridge.ts

@@ -417,19 +417,20 @@ class Bridge {
 
 function main(): void {
   const args = process.argv.slice(2);
-  if (args.length === 1 && (args[0] === "-h" || args[0] === "--help")) {
+  const [flag, configPath] = args;
+  if (args.length === 1 && (flag === "-h" || flag === "--help")) {
     process.stdout.write(
       "Usage: node dist/pi-intercom/bridge.js --config PATH\n\nOptional loopback HTTPS/mTLS bridge for the local pi-intercom broker.\nConfig and TLS key must be owned by you with mode 0600.\nWithout stateDir, messaging never starts the broker. Durable presence safely starts\none only when none is running; it never restarts or replaces a live broker.\nSIGHUP reloads the client allowlist (invalid reload denies all clients).\nRestart this helper for TLS/listener rotation. SIGINT/SIGTERM disconnect peers.\n\nExample: node dist/pi-intercom/bridge.js --config ~/.pi/agent/intercom/bridge.json\n",
     );
     return;
   }
-  if (args.length !== 2 || args[0] !== "--config" || args[1] === "") {
+  if (args.length !== 2 || flag !== "--config" || configPath === undefined || configPath === "") {
     process.stderr.write("Usage: node dist/pi-intercom/bridge.js --config PATH (or --help)\n");
     process.exitCode = 2;
     return;
   }
   try {
-    const path = resolve(args[1]);
+    const path = resolve(configPath);
     new Bridge(loadConfig(path), path).start();
   } catch (error) {
     if (error instanceof Fault) {

package/src/pi-intercom/broker/broker.ts

@@ -303,7 +303,7 @@ class IntercomBroker {
     }
     const targets = findSessions(this.sessions, msg.to, currentId);
     const target = targets[0];
-    if (targets.length === 1) {
+    if (targets.length === 1 && target !== undefined) {
       const guardError = guardedDeliveryError(this.sessions, msg.to, message);
       if (guardError !== null) {
         writeMessage(socket, {

package/src/pi-intercom/broker/client-last.ts

@@ -24,7 +24,7 @@ export function lastRequest(msg: UnknownRecord): {
   readonly requestId: string;
   readonly from: SessionInfo;
   readonly query: NativeReadQuery;
-  readonly parked?: SessionInfo;
+  readonly parked?: SessionInfo | undefined;
 } {
   const from = normalizeSessionInfo(msg.from);
   if (typeof msg.requestId !== "string" || !from || !isNativeReadQuery(msg.query)) {

package/src/pi-intercom/broker/client-park.ts

@@ -4,7 +4,7 @@ import { writeMessage } from "./framing.ts";
 /** Parking negotiation and its single outstanding broker acknowledgement. */
 export class ParkRequests {
   supported = false;
-  private acknowledged?: (parked: boolean) => void;
+  private acknowledged?: ((parked: boolean) => void) | undefined;
   settle(parked: boolean): void {
     this.acknowledged?.(parked);
   }

package/src/pi-intercom/broker/client.ts

@@ -516,15 +516,15 @@ export class IntercomClient extends EventEmitter {
   }
 
   updatePresence(updates: {
-    readonly applicationGuard?: string | null;
-    readonly name?: string;
-    readonly status?: string;
-    readonly model?: string;
-    readonly pendingAsks?: number;
-    readonly acceptsAsks?: boolean;
-    readonly lastIntercomActivity?: number;
-    readonly subscriptions?: SessionInfo["subscriptions"];
-    readonly topics?: readonly TopicUpdate[];
+    readonly applicationGuard?: string | null | undefined;
+    readonly name?: string | undefined;
+    readonly status?: string | undefined;
+    readonly model?: string | undefined;
+    readonly pendingAsks?: number | undefined;
+    readonly acceptsAsks?: boolean | undefined;
+    readonly lastIntercomActivity?: number | undefined;
+    readonly subscriptions?: SessionInfo["subscriptions"] | undefined;
+    readonly topics?: readonly TopicUpdate[] | undefined;
   }): void {
     if (this.disconnecting) {
       return;

package/src/pi-intercom/broker/framing.ts

@@ -58,10 +58,16 @@ class MessageBuffer {
     if (size === 0) {
       return Buffer.alloc(0);
     }
+    if (first === undefined) {
+      throw new Error("Frame reader has no buffered chunk for a non-empty read.");
+    }
     const result = first.length >= size ? first.subarray(0, size) : Buffer.allocUnsafe(size);
     let written = 0;
     while (written < size) {
       const chunk = this.chunks[this.index];
+      if (chunk === undefined) {
+        throw new Error("Frame reader ran out of buffered chunks mid-read.");
+      }
       const count = Math.min(chunk.length, size - written);
       if (first.length < size) {
         chunk.copy(result, written, 0, count);

package/src/pi-intercom/broker/last.ts

@@ -100,13 +100,13 @@ interface LastPeer {
   readonly info: SessionInfo;
   readonly lastMessages: boolean;
   readonly receiptReads: boolean;
-  readonly parked?: { readonly closed: boolean };
+  readonly parked?: { readonly closed: boolean } | undefined;
 }
 interface PendingLast {
   readonly fromId: string;
   readonly toId: string;
   /** A parked child's main answers from the child's captured native history. */
-  readonly via?: string;
+  readonly via?: string | undefined;
   readonly requestId: string;
   readonly query: NativeReadQuery;
   readonly timer: NodeJS.Timeout;
@@ -130,24 +130,25 @@ function unavailable(
   targets: readonly LastPeer[],
   name: string,
   pending: number,
-  { query, via }: { readonly query: NativeReadQuery; readonly via?: LastPeer },
+  { query, via }: { readonly query: NativeReadQuery; readonly via?: LastPeer | undefined },
 ): string | undefined {
-  if (targets.length === 0) {
+  const [target] = targets;
+  if (target === undefined) {
     return "Session not found";
   }
   if (targets.length > 1) {
     return `Multiple sessions named "${name}" are connected. Use the session ID instead.`;
   }
-  const exited = exitedRefusal(targets[0], query, via);
+  const exited = exitedRefusal(target, query, via);
   if (exited !== undefined) {
     return exited;
   }
-  if (!targets[0].lastMessages) {
+  if (!target.lastMessages) {
     return "Recipient does not support last-message reads; reload its extension.";
   }
   if (
     "messageId" in query &&
-    (!targets[0].receiptReads || targets[0].info.rootSessionId !== query.rootSessionId)
+    (!target.receiptReads || target.info.rootSessionId !== query.rootSessionId)
   ) {
     return "publication_unavailable";
   }
@@ -213,19 +214,19 @@ export class LastMessageRelay {
   ): void {
     const message = lastRequest(input);
     const targets = findSessions(this.sessions, message.to, fromId);
-    const target = targets[0];
     const from = this.sessions.get(fromId);
     if (!from) {
       return;
     }
     const token = randomUUID();
-    const via = targets.length === 1 ? reader(target.info.id) : undefined;
+    const delegated = this.delegatedReader(targets, reader);
+    const via = delegated?.via;
     const frame = {
       type: "last_request" as const,
       requestId: token,
       from: messageSender(from.info),
       query: message.query,
-      parked: via && messageSender(target.info),
+      parked: delegated === undefined ? undefined : messageSender(delegated.target.info),
     };
     const error =
       unavailable(targets, message.to, this.pending.size, { query: message.query, via }) ??
@@ -238,24 +239,67 @@ export class LastMessageRelay {
       });
       return;
     }
+    const [recipient] = targets;
+    if (recipient === undefined) {
+      return;
+    }
+    this.forward(
+      { token, fromId, requestId: message.requestId, query: message.query },
+      recipient,
+      via,
+      frame,
+    );
+  }
+
+  /** Register the correlated wait, then forward the read to the reader or the recipient. */
+  private forward(
+    wait: {
+      readonly token: string;
+      readonly fromId: string;
+      readonly requestId: string;
+      readonly query: NativeReadQuery;
+    },
+    recipient: LastPeer,
+    via: LastPeer | undefined,
+    frame: {
+      readonly type: "last_request";
+      readonly requestId: string;
+      readonly from: SessionInfo;
+      readonly query: NativeReadQuery;
+      readonly parked?: SessionInfo | undefined;
+    },
+  ): void {
     const timer = setTimeout(
-      () => this.finish(token, { error: "Last-message read timed out" }),
+      () => this.finish(wait.token, { error: "Last-message read timed out" }),
       5000,
     );
     timer.unref();
-    this.pending.set(token, {
-      fromId,
-      toId: target.info.id,
+    this.pending.set(wait.token, {
+      fromId: wait.fromId,
+      toId: recipient.info.id,
       via: via?.info.id,
-      requestId: message.requestId,
-      query: message.query,
+      requestId: wait.requestId,
+      query: wait.query,
       timer,
     });
     try {
-      writeMessage((via ?? target).socket, frame);
+      writeMessage((via ?? recipient).socket, frame);
     } catch {
-      this.finish(token, { error: "Recipient disconnected before last-message read" });
+      this.finish(wait.token, { error: "Recipient disconnected before last-message read" });
+    }
+  }
+
+  /** A sole matched target may delegate the read to another peer's captured history. */
+  private delegatedReader(
+    targets: readonly LastPeer[],
+    reader: (id: string) => LastPeer | undefined,
+  ): { readonly target: LastPeer; readonly via: LastPeer } | undefined {
+    const [target] = targets;
+    if (targets.length !== 1 || target === undefined) {
+      return undefined;
     }
+    const via = reader(target.info.id);
+    return via === undefined ? undefined : { target, via };
   }
 
   respond(fromId: string, message: UnknownRecord): void {

package/src/pi-intercom/broker/parked.ts

@@ -21,8 +21,8 @@ interface Parked {
   readonly retained: Retained;
   /** The fenced actor's socket closed: input waits for its restored replacement. */
   closed: boolean;
-  attempt?: WakeAttempt;
-  lastFailure?: string;
+  attempt?: WakeAttempt | undefined;
+  lastFailure?: string | undefined;
 }
 export interface ParkablePeer {
   readonly socket: net.Socket;
@@ -31,7 +31,7 @@ export interface ParkablePeer {
   readonly parking: boolean;
   readonly wakeResults: boolean;
   readonly wakeNotices: boolean;
-  parked?: Parked;
+  parked?: Parked | undefined;
 }
 export function reachable<T extends ParkablePeer>(target?: T): target is T {
   const socket = target?.socket;
@@ -101,7 +101,10 @@ export class ParkedSessions<T extends ParkablePeer> {
     }
   }
   /** A free requested identity, or a parked one resumed by the same child lineage. */
-  claim(requestedId: unknown, next: Omit<SessionInfo, "id">): { id: string; resumed?: T } {
+  claim(
+    requestedId: unknown,
+    next: Omit<SessionInfo, "id">,
+  ): { id: string; resumed?: T | undefined } {
     const id = requested(requestedId);
     const previous = id === undefined ? undefined : this.sessions.get(id);
     const resumes =
@@ -112,7 +115,7 @@ export class ParkedSessions<T extends ParkablePeer> {
       return { id: randomUUID() };
     }
     previous?.socket.destroy();
-    return { id, resumed: previous };
+    return { id, ...(previous !== undefined ? { resumed: previous } : {}) };
   }
   /** Flushes a restored child's input and re-sends wakes owed to a (re)registered main. */
   registered(id: string, previous?: T): void {

package/src/pi-intercom/config.ts

@@ -12,7 +12,7 @@ export interface IntercomConfig {
   /** Require confirmation before non-reply sends from interactive sessions. */
   readonly confirmSend: boolean;
   /** Optional custom status suffix shown after automatic lifecycle status. */
-  readonly status?: string;
+  readonly status?: string | undefined;
   /** Show reply hint in incoming messages (default: true). */
   readonly replyHint: boolean;
   /** Ordinary ask reply timeout, in milliseconds (default: 120000 = 2 minutes). */

package/src/pi-intercom/outbound.ts

@@ -93,6 +93,7 @@ export class IntercomOutbound {
       case "queue":
         return " (intentionally deferred behind active recipient work)";
       case undefined:
+      default:
         return " (defaults to steer; wakes idle recipients and steers active recipients after the current tool call)";
     }
   }

package/src/pi-intercom/reply-tracker.ts

@@ -79,8 +79,9 @@ function explicitReply(
 }
 function replyBySender(contexts: readonly IntercomContext[], to: string): IntercomContext {
   const matches = matchingSender(contexts, to);
-  if (matches.length === 1) {
-    return matches[0];
+  const [onlyMatch] = matches;
+  if (matches.length === 1 && onlyMatch !== undefined) {
+    return onlyMatch;
   }
   if (matches.length > 1) {
     throw new RecoveryError(
@@ -164,7 +165,7 @@ export class ReplyTracker {
     const beforeQueued = this.pendingTurnContexts.length;
     for (let index = this.pendingTurnContexts.length - 1; index >= 0; index -= 1) {
       const context = this.pendingTurnContexts[index];
-      if (expires(context)) {
+      if (context !== undefined && expires(context)) {
         this.pendingTurnContexts.splice(index, 1);
       }
     }
@@ -181,7 +182,7 @@ export class ReplyTracker {
   }
 
   resolveReplyTarget(
-    options: { readonly to?: string; readonly replyTo?: string },
+    options: { readonly to?: string | undefined; readonly replyTo?: string | undefined },
     now = Date.now(),
   ): IntercomContext {
     this.pruneExpired(now);
@@ -204,11 +205,17 @@ export class ReplyTracker {
     if (to !== "") {
       return replyBySender(contexts, to);
     }
+    return this.implicitReplyTarget(pending);
+  }
+
+  /** Without an explicit target, the turn context wins, then a sole pending ask. */
+  private implicitReplyTarget(pending: readonly IntercomContext[]): IntercomContext {
     if (this.currentTurnContext) {
       return this.currentTurnContext;
     }
-    if (pending.length === 1) {
-      return pending[0];
+    const [solePending] = pending;
+    if (pending.length === 1 && solePending !== undefined) {
+      return solePending;
     }
     if (pending.length === 0) {
       throw new RecoveryError("no_pending_reply", "No active intercom context to reply to");

package/src/pi-intercom/reply-wait.ts

@@ -15,13 +15,13 @@ interface ReplyWaiter {
 export interface ReplyWaitOptions {
   readonly from: string;
   readonly replyTo: string;
-  readonly signal?: AbortSignal;
+  readonly signal?: AbortSignal | undefined;
 }
 export interface AskTransaction {
   readonly to: string;
   readonly questionId: string;
   readonly options: Parameters<IntercomClient["send"]>[1];
-  readonly signal?: AbortSignal;
+  readonly signal?: AbortSignal | undefined;
   readonly onSent: (result: SendResult) => void;
 }
 /** One correlated blocking wait; admitted before send so a fast reply cannot race it. */
@@ -53,7 +53,7 @@ export class ReplyWait {
     }
   }
   receive(
-    sender: { readonly id: string; readonly name?: string },
+    sender: { readonly id: string; readonly name?: string | undefined },
     message: Message,
     onMatch: () => void,
   ): boolean {

package/src/pi-intercom/runtime-types.ts

@@ -3,7 +3,7 @@ import type { Attachment, Message, MessageDelivery, QueueMode, SessionInfo } fro
 export interface InboundMessageEntry {
   readonly from: SessionInfo;
   readonly message: Message;
-  readonly replyCommand?: string;
+  readonly replyCommand?: string | undefined;
   readonly bodyText: string;
 }
 export interface PendingInboundMessage extends InboundMessageEntry {