@fitchmultz/pi-subagents 0.49.0 → 0.50.0

package/src/pi-intercom/tool-registration.ts

@@ -1,121 +1,21 @@
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
 import type { IntercomTools } from "./tools.ts";
-import type { IntercomSupervisor } from "./supervisor.ts";
-import type { ToolResultLike } from "./runtime-types.ts";
-import { Type } from "../shared/native-typebox.ts";
-import { activateTools } from "../shared/lazy-tools.ts";
 import { throwIfToolError } from "./tool-results.ts";
-import { intercomSchema, contactSupervisorSchema } from "./tool-schemas.ts";
-import {
-  renderContactCall,
-  renderContactResult,
-  renderIntercomCall,
-  renderIntercomResult,
-} from "./ui/tool-renderers.ts";
-type MessagingTool = Readonly<Pick<IntercomTools, "execute">>;
-type SupervisorTool = Readonly<Pick<IntercomSupervisor, "execute">>;
+import { intercomSchema } from "./tool-schemas.ts";
 
-function nativeResult(result: ToolResultLike): {
-  content: { type: "text"; text: string }[];
-  details: Readonly<Record<string, unknown>> | undefined;
-  isError: false;
-} {
-  const success = throwIfToolError(result);
-  return { content: [...success.content], details: success.details, isError: false };
-}
-function registerContact(pi: ExtensionAPI, supervisor: SupervisorTool): void {
-  pi.registerTool({
-    name: "contact_supervisor",
-    label: "Contact Supervisor",
-    description:
-      "Subagent-only tool for contacting the supervisor agent that delegated this task. Use need_decision only when this child cannot safely continue without a decision, approval, or product/API/scope clarification; this steers the supervisor at its next tool boundary and keeps the child alive for the reply. Use interview_request only when multiple structured answers are all required before safe progress; this also steers and waits. Use progress_update only for a discovery or change the supervisor needs while working; it steers at the next tool boundary without waiting for a reply. Skip starts, redundant status, and routine completion; retain material findings in the final result.",
-    promptSnippet:
-      "Subagent-only: steer the supervisor for required decisions, structured interviews, or material discoveries needed during active work. Skip routine status and completion messages.",
-    promptGuidelines: [
-      "Use contact_supervisor with reason='need_decision' when a subagent cannot safely continue without a decision, approval, or product/API/scope clarification; it steers the supervisor and waits for the reply.",
-      "Use contact_supervisor with reason='interview_request' only when the child cannot safely continue until it receives multiple structured answers in one blocking steered exchange.",
-      "Use contact_supervisor with reason='progress_update' only for a discovery or change the supervisor needs while working. It steers at the next tool boundary without waiting. Skip starts, redundant narration, and routine completion; keep material findings in the final result.",
-      "Do not use contact_supervisor for routine completion handoffs; return the final subagent result normally.",
-    ],
-    parameters: contactSupervisorSchema,
-    async execute(_id, params, signal, _update, ctx) {
-      return nativeResult(await supervisor.execute(params, signal, ctx));
-    },
-    renderCall: renderContactCall,
-    renderResult: renderContactResult,
-  });
-}
-function registerLoader(pi: ExtensionAPI): void {
-  pi.registerTool({
-    name: "load_intercom",
-    label: "Load Intercom",
-    description:
-      "Enable local peer coordination: list/check sessions before shared-state work, send or reply to messages, and inspect/publish topics. Does not send a message or check peers itself.",
-    parameters: Type.Object({}),
-    async execute() {
-      if (
-        !pi.getAllTools().some((tool) => tool.name === "intercom" && tool.namespace === undefined)
-      ) {
-        throw new Error("Intercom is excluded from this session.");
-      }
-      activateTools(pi, ["intercom"]);
-      return {
-        content: [
-          {
-            type: "text",
-            text: "Intercom enabled. Use intercom({action:'list'}) to check peers, or status, pending, reply, send, ask and topics for coordination.",
-          },
-        ],
-        details: {},
-      };
-    },
-  });
-}
-function registerMessaging(pi: ExtensionAPI, tools: MessagingTool): void {
+export function registerIntercomTools(
+  pi: ExtensionAPI,
+  tools: Readonly<Pick<IntercomTools, "execute">>,
+): void {
   pi.registerTool({
     name: "intercom",
-    defaultActive: false,
     label: "Intercom",
-    description: `Send a message to another pi session running on this machine.
-Use this to communicate findings, request help, or coordinate work with other sessions.
-Non-blocking send defaults to steer for guidance, answers, corrections, or blockers that may affect active work. Use queue only when delay is intentional; use ask only when this process must remain alive waiting for the reply.
-
-Usage:
-  intercom({ action: "list" })                    → List sessions in this repository and its worktrees
-  intercom({ action: "list", scope: "all" })      → List connected sessions across every project
-  intercom({ action: "send", to: "session-name", message: "..." })  → Send live coordination (defaults to steer)
-  intercom({ action: "ask", to: "session-name", delivery: "steer", message: "..." })   → Blocking wait only when sender must stay alive
-  intercom({ action: "reply", message: "..." })                      → Reply to the active/single pending ask
-  intercom({ action: "pending" })                                      → List unresolved inbound asks
-  intercom({ action: "status" })                  → Show connection status
-  intercom({ action: "subscribe", topic: "project/work", awaitRelease: true }) → Opt into a topic
-  intercom({ action: "publish", topic: "project/work", message: "Current self-contained state" }) → Quiet latest state
-  intercom({ action: "topics" }) → Inspect topics and current resource owners`,
-    promptSnippet:
-      "Coordinate with local Pi sessions. Non-blocking send defaults to steer for live agent guidance; queue only for intentional delay and ask only for a required blocking reply.",
-    promptGuidelines: [
-      "Intercom list/status defaults to the current Git repository and its worktrees. Use scope='all' only when intentionally discovering sessions in other projects.",
-      "Action='send' defaults to delivery='steer' for agent-to-agent guidance, answers, corrections, blockers, or other context that may affect active work.",
-      "Use delivery='queue' only when delay is intentional. For routine status, explicitly subscribe/publish topics: updates replace quiet inspectable state outside model context, not passive conversation messages. Topic blockers/decisions and awaited ownership releases interrupt; direct messages always bypass subscriptions.",
-      "Treat inbound steered messages as supplemental coordination within the active task: incorporate relevant context and continue; replace the task only when the message explicitly says so.",
-      "Use action='reply' for an active inbound ask. Otherwise respond with send plus steer; use blocking ask only when this process must stay alive and cannot safely continue without the answer.",
-    ],
+    description:
+      "Discover and message connected Pi sessions in your collaboration group; main sessions can also reach other mains, across projects. Use list for unambiguous targets. Send defaults to steer at the next tool boundary; queue defers; passive never wakes the model. Ask waits for a correlated reply; reply answers the active or single pending ask (specify replyTo when ambiguous). Pending lists asks; status shows connection and inbound queue state. Last reads a peer's original completed assistant response without waking it; page using entryId and nextOffset. Broker acceptance is not recipient persistence, consumption, or task completion.",
     parameters: intercomSchema,
     async execute(_id, params, signal, _update, ctx) {
-      return nativeResult(await tools.execute(params, signal, ctx));
+      const result = throwIfToolError(await tools.execute(params, signal, ctx));
+      return { content: [...result.content], details: result.details };
     },
-    renderCall: renderIntercomCall,
-    renderResult: renderIntercomResult,
   });
 }
-export function registerIntercomTools(
-  pi: ExtensionAPI,
-  tools: MessagingTool,
-  supervisor: SupervisorTool | null,
-): void {
-  if (supervisor) {
-    registerContact(pi, supervisor);
-  }
-  registerLoader(pi);
-  registerMessaging(pi, tools);
-}

package/src/pi-intercom/tool-schemas.ts

@@ -1,60 +1,14 @@
 import { StringEnum } from "@earendil-works/pi-ai";
-import { Type } from "../shared/native-typebox.ts";
-export const contactSupervisorSchema = Type.Object({
-  reason: StringEnum(["need_decision", "progress_update", "interview_request"] as const, {
+import { Type } from "../agent/typebox.ts";
+export const intercomSchema = Type.Object({
+  action: StringEnum(["list", "send", "ask", "reply", "pending", "status", "last"] as const, {
     description:
-      "Contact reason: 'need_decision' and 'interview_request' steer the supervisor and wait for a reply; 'progress_update' steers a material discovery without waiting for a reply",
+      "List, send, ask, reply, pending asks, connection status, or last completed assistant response.",
   }),
-  message: Type.Optional(
-    Type.String({
-      description:
-        "Decision request, optional interview note, or meaningful progress update for the supervisor",
-    }),
-  ),
-  interview: Type.Optional(
-    Type.Object(
-      {
-        title: Type.Optional(Type.String()),
-        description: Type.Optional(Type.String()),
-        questions: Type.Array(
-          Type.Object({
-            id: Type.String(),
-            type: StringEnum(["single", "multi", "text", "image", "info"] as const, {
-              description: "Question type: single, multi, text, image, or info",
-            }),
-            question: Type.String(),
-            options: Type.Optional(Type.Array(Type.Unknown())),
-            context: Type.Optional(Type.String()),
-          }),
-        ),
-      },
-      { description: "Structured interview request for reason='interview_request'" },
-    ),
-  ),
-});
-export const intercomSchema = Type.Object({
-  action: StringEnum(
-    [
-      "list",
-      "send",
-      "ask",
-      "reply",
-      "pending",
-      "status",
-      "subscribe",
-      "unsubscribe",
-      "publish",
-      "topics",
-    ] as const,
-    {
-      description:
-        "Direct messages: list/send/ask/reply/pending/status. Quiet state: subscribe/unsubscribe/publish/topics.",
-    },
-  ),
   scope: Type.Optional(
     StringEnum(["project", "all"] as const, {
       description:
-        "For list/status: 'project' (default) shows this Git repository and its worktrees; 'all' includes sessions in other projects.",
+        "For list/status: 'all' (default) includes every reachable session; 'project' further filters this repository and its worktrees.",
     }),
   ),
   to: Type.Optional(
@@ -62,37 +16,9 @@ export const intercomSchema = Type.Object({
       description: "Target session name or ID (for 'send', 'ask', or disambiguating 'reply')",
     }),
   ),
-  topic: Type.Optional(
-    Type.String({
-      description:
-        "Exact opt-in topic for subscribe/unsubscribe/publish/topics; no automatic subscriptions.",
-    }),
-  ),
-  event: Type.Optional(
-    StringEnum(["update", "blocker", "decision", "release"] as const, {
-      description:
-        "Publish: update is quiet current state. Blockers/decisions interrupt subscribers; release interrupts only those awaiting release.",
-    }),
-  ),
-  resource: Type.Optional(
-    Type.String({
-      description: "Publish: resource this session is using (advisory ownership, not a lock).",
-    }),
-  ),
-  ownership: Type.Optional(
-    StringEnum(["held", "released"] as const, {
-      description:
-        "Publish: this session's declared resource state. Disconnect never implies released.",
-    }),
-  ),
-  awaitRelease: Type.Optional(
-    Type.Boolean({
-      description: "Subscribe: interrupt when this topic explicitly releases ownership.",
-    }),
-  ),
   message: Type.Optional(
     Type.String({
-      description: "Message for send/ask/reply, or self-contained latest state for publish",
+      description: "Message for send/ask/reply",
     }),
   ),
   attachments: Type.Optional(
@@ -125,6 +51,17 @@ export const intercomSchema = Type.Object({
   threadId: Type.Optional(
     Type.String({ description: "Stable topic key for queueMode='replace'." }),
   ),
+  entryId: Type.Optional(Type.String({ description: "Last response entry ID for stable paging." })),
+  offset: Type.Optional(
+    Type.Integer({ minimum: 0, description: "Last response character offset (UTF-16)." }),
+  ),
+  limit: Type.Optional(
+    Type.Integer({
+      minimum: 1,
+      maximum: 16384,
+      description: "Last response page size; default/max 16384 characters.",
+    }),
+  ),
   passive: Type.Optional(
     Type.Boolean({
       description:

package/src/pi-intercom/tools.ts

@@ -1,21 +1,38 @@
 import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
 import type { IntercomTransport } from "./transport.ts";
-import type { IntercomConnection } from "./connection.ts";
+import { resolveConnectedTarget, type IntercomConnection } from "./connection.ts";
 import type { IntercomOutbound } from "./outbound.ts";
-import type { IntercomTopicActions } from "./topic-actions.ts";
-import type { IntercomTopics } from "./topics.ts";
 import type { IntercomInspection } from "./inspection.ts";
 import type { IntercomToolParams, ToolResultLike } from "./runtime-types.ts";
-import { validateIntercomArguments, toolError, toolText } from "./tool-arguments.ts";
+import { validateIntercomArguments, toolError } from "./tool-arguments.ts";
 import { errorMessage } from "./validation.ts";
-type Connection = Readonly<Pick<IntercomConnection, "ensure" | "syncIdentity">>;
-type TopicOwner = Readonly<Pick<IntercomTopics, "disconnected" | "inspect">>;
+import type { LastMessageResult } from "./types.ts";
+
+function lastPage(result: Exclude<LastMessageResult, { readonly error: string }>): ToolResultLike {
+  const identity = `${result.session.name ?? result.session.id} (${result.session.id})`;
+  const page =
+    result.entryId === null
+      ? "No completed assistant response."
+      : `Entry: ${result.entryId}\nCharacters (UTF-16): ${result.offset}–${result.offset + result.text.length} of ${result.totalLength}`;
+  const next =
+    result.nextOffset === undefined
+      ? ""
+      : `\nNext page: intercom(${JSON.stringify({ action: "last", to: result.session.id, entryId: result.entryId, offset: result.nextOffset })})`;
+  return {
+    content: [
+      { type: "text", text: result.text },
+      {
+        type: "text",
+        text: `Session: ${identity}\nStatus: ${result.session.status ?? "unknown"}\n${page}${next}`,
+      },
+    ],
+    details: { ...result },
+  };
+}
 
 interface ToolOwners {
-  readonly connection: Connection;
+  readonly connection: Readonly<Pick<IntercomConnection, "ensure" | "syncIdentity">>;
   readonly outbound: Readonly<Pick<IntercomOutbound, "send" | "ask" | "reply">>;
-  readonly topicActions: Readonly<Pick<IntercomTopicActions, "execute">>;
-  readonly topics: TopicOwner;
   readonly inspection: Readonly<Pick<IntercomInspection, "list" | "status" | "pending">>;
 }
 export class IntercomTools {
@@ -23,25 +40,49 @@ export class IntercomTools {
   constructor(owners: ToolOwners) {
     this.owners = owners;
   }
-  private async dispatch(
-    active: IntercomTransport,
+  async execute(
     params: IntercomToolParams,
     signal: AbortSignal | undefined,
     ctx: ExtensionContext,
   ): Promise<ToolResultLike> {
-    const scope = params.scope ?? "project";
+    const invalid = validateIntercomArguments(params);
+    if (invalid) {
+      return invalid;
+    }
+    let active: IntercomTransport;
+    try {
+      active = await this.owners.connection.ensure();
+    } catch (error) {
+      return toolError(`Intercom not connected: ${errorMessage(error)}`);
+    }
+    this.owners.connection.syncIdentity(ctx.sessionManager.getSessionId());
+    const scope = params.scope ?? "all";
     switch (params.action) {
-      case "subscribe":
-      case "unsubscribe":
-      case "publish":
-      case "topics":
-        return await this.owners.topicActions.execute(active, params, ctx);
       case "list":
         return await this.owners.inspection.list(active, scope);
       case "status":
         return await this.owners.inspection.status(active, scope, ctx);
       case "pending":
         return this.owners.inspection.pending();
+      case "last": {
+        if (params.to === undefined || params.to === "") {
+          return toolError("Missing 'to' parameter");
+        }
+        try {
+          const target = (await resolveConnectedTarget(active, params.to)) ?? params.to;
+          const result = await active.last(target, {
+            entryId: params.entryId,
+            offset: params.offset,
+            limit: params.limit,
+          });
+          if ("error" in result) {
+            return toolError(result.error);
+          }
+          return lastPage(result);
+        } catch (error) {
+          return toolError(`Failed to read last response: ${errorMessage(error)}`);
+        }
+      }
       case "send":
         return await this.owners.outbound.send(active, params, ctx);
       case "ask":
@@ -50,31 +91,4 @@ export class IntercomTools {
         return await this.owners.outbound.reply(active, params);
     }
   }
-  async execute(
-    params: IntercomToolParams,
-    signal: AbortSignal | undefined,
-    ctx: ExtensionContext,
-  ): Promise<ToolResultLike> {
-    let active: IntercomTransport;
-    try {
-      active = await this.owners.connection.ensure("tool");
-    } catch (error) {
-      if (params.action === "topics") {
-        this.owners.topics.disconnected();
-        return toolText(
-          `Broker unavailable; last saved records follow.\n${this.owners.topics.inspect(params.topic)}`,
-          { connection: "disconnected" },
-        );
-      }
-      return toolError(`Intercom not connected: ${errorMessage(error)}`);
-    }
-    this.owners.connection.syncIdentity(ctx.sessionManager.getSessionId());
-    if (!["subscribe", "unsubscribe", "publish", "topics"].includes(params.action)) {
-      const invalid = validateIntercomArguments(params);
-      if (invalid) {
-        return invalid;
-      }
-    }
-    return await this.dispatch(active, params, signal, ctx);
-  }
 }

package/src/pi-intercom/transport.ts

@@ -4,6 +4,7 @@ export type IntercomTransport = Readonly<
   Pick<
     IntercomClient,
     | "send"
+    | "last"
     | "isConnected"
     | "sessionId"
     | "supportsTopics"

package/src/pi-intercom/types.ts

@@ -8,7 +8,6 @@ import {
   safeLabel,
   safeText,
 } from "./validation.ts";
-import type { NativeControlEnvelope } from "./native-control-protocol.ts";
 
 export interface SessionInfo {
   readonly id: string;
@@ -17,6 +16,8 @@ export interface SessionInfo {
   readonly model: string;
   /** Opaque same-repository/worktree identity used for ambient peer awareness. */
   readonly projectId?: string;
+  readonly rootSessionId?: string;
+  readonly parentSessionId?: string;
   readonly status?: string;
   readonly lastSeen?: number;
   readonly lastIntercomActivity?: number;
@@ -107,7 +108,6 @@ export interface Message {
   readonly timestamp: number;
   readonly replyTo?: string;
   readonly expectsReply?: boolean;
-  readonly control?: NativeControlEnvelope;
   /** Recipients verify parent ownership before elevating human origin. */
   readonly human?: HumanMessageOrigin;
   readonly topic?: TopicUpdate;
@@ -252,17 +252,27 @@ function validSessionTopics(session: Readonly<Record<string, unknown>>): boolean
   );
 }
 
+function validSessionLineage(value: Readonly<Record<string, unknown>>): boolean {
+  return (
+    optionalLabel(value.rootSessionId) &&
+    optionalLabel(value.parentSessionId) &&
+    (value.parentSessionId === undefined || value.rootSessionId === value.parentSessionId)
+  );
+}
+
+function validSessionProject(value: unknown): boolean {
+  return value === undefined || (typeof value === "string" && /^[a-f0-9]{64}$/.test(value));
+}
+
 export function isSessionRegistration(value: unknown): value is Omit<SessionInfo, "id"> {
   if (!isRecord(value) || !safeLabel(value.cwd) || !safeLabel(value.model)) {
     return false;
   }
-  const validProject =
-    value.projectId === undefined ||
-    (typeof value.projectId === "string" && /^[a-f0-9]{64}$/.test(value.projectId));
   return (
     optionalLabel(value.name) &&
     optionalLabel(value.status) &&
-    validProject &&
+    validSessionLineage(value) &&
+    validSessionProject(value.projectId) &&
     validSessionHealth(value) &&
     validSessionTopics(value)
   );
@@ -345,12 +355,30 @@ export function normalizeMessage(value: unknown): Message | null {
   return isMessage(restored) ? restored : null;
 }
 
+export interface LastMessageQuery {
+  readonly entryId?: string;
+  readonly offset?: number;
+  readonly limit?: number;
+}
+
+export type LastMessageResult =
+  | {
+      readonly session: SessionInfo;
+      readonly entryId: string | null;
+      readonly text: string;
+      readonly offset: number;
+      readonly totalLength: number;
+      readonly nextOffset?: number;
+    }
+  | { readonly error: string };
+
 export type BrokerMessage =
   | {
       readonly type: "registered";
       readonly sessionId: string;
       readonly topicsSupported?: true;
       readonly topicFrames?: true;
+      readonly lastMessages?: true;
     }
   | {
       readonly type: "sessions";
@@ -365,6 +393,17 @@ export type BrokerMessage =
       readonly from: SessionInfo;
       readonly message: Message | CompactTopicMessage;
     }
+  | {
+      readonly type: "last_request";
+      readonly requestId: string;
+      readonly from: SessionInfo;
+      readonly query: LastMessageQuery;
+    }
+  | {
+      readonly type: "last_response";
+      readonly requestId: string;
+      readonly result: LastMessageResult;
+    }
   | { readonly type: "session_left"; readonly sessionId: string }
   | { readonly type: "delivered"; readonly messageId: string }
   | { readonly type: "delivery_queued"; readonly messageId: string; readonly reason: string }

package/src/pi-intercom/ui/session-format.ts

@@ -8,7 +8,7 @@ function shellQuote(value: string): string {
   return `'${value.replace(/'/g, `'\\''`)}'`;
 }
 function localForkStartCommand(): string {
-  return `pi --name worker --extension ${shellQuote(path.join(PACKAGE_ROOT, "src", "pi-intercom", "index.ts"))} --skill ${shellQuote(path.join(PACKAGE_ROOT, "skills", "pi-intercom"))}`;
+  return `pi --name worker --extension ${shellQuote(path.join(PACKAGE_ROOT, "src", "index.ts"))}`;
 }
 function duplicateNames(sessions: readonly SessionInfo[]): ReadonlySet<string> {
   const names = sessions
@@ -121,7 +121,7 @@ function noPeers(hidden: number): string {
 export function formatSessionListSections(
   allSessions: readonly SessionInfo[],
   id: string,
-  scope: IntercomSessionScope = "project",
+  scope: IntercomSessionScope = "all",
 ): string {
   const current = allSessions.find((session) => session.id === id);
   if (!current) {
@@ -140,7 +140,7 @@ export function formatSessionListSections(
   const otherSection = `**Other sessions:**\n${others.length === 0 ? noPeers(hidden) : others.map((session) => row(session, { ...options, self: false })).join("\n")}`;
   const hint =
     hidden > 0
-      ? `\n\n${hidden} session${hidden === 1 ? "" : "s"} in other projects hidden. Use \`intercom({ action: "list", scope: "all" })\` to show every connected session.`
+      ? `\n\n${hidden} session${hidden === 1 ? "" : "s"} in other projects hidden. Use \`intercom({ action: "list", scope: "all" })\` to show every reachable session.`
       : "";
   return `${currentSection}\n\n${otherSection}${hint}`;
 }

package/src/shared/journal-projections.ts

@@ -1,41 +1,6 @@
 import type { Projection } from "./json-projection.ts";
 import { isUnknownArray, recordAt, type UnknownRecord } from "./unknown.ts";
 
-function resultField(path: readonly (string | number)[]): boolean {
-  if (path.length === 2) {
-    return path[0] === "result";
-  }
-  if (path.length === 3) {
-    return path[0] === "results" && typeof path[1] === "number";
-  }
-  return (
-    path.length === 4 &&
-    path[0] === "children" &&
-    typeof path[1] === "number" &&
-    path[2] === "result"
-  );
-}
-function summaryField(path: readonly (string | number)[]): boolean {
-  return (
-    (path.length === 1 && path[0] === "summary") ||
-    (path.length === 3 &&
-      path[0] === "children" &&
-      typeof path[1] === "number" &&
-      path[2] === "summary")
-  );
-}
-export const ownerProjection: Projection = (path) => {
-  const field = path.at(-1);
-  if (resultField(path)) {
-    if (field === "messages") {
-      return false;
-    }
-    if (["output", "finalOutput", "initialOutput", "rawOutput"].includes(String(field))) {
-      return 8192;
-    }
-  }
-  return summaryField(path) ? 8192 : true;
-};
 const entryFields = new Set([
   "type",
   "id",

package/src/shared/post-exit-stdio-guard.ts

@@ -1,8 +1,14 @@
 import { execFileSync, type ChildProcess } from "node:child_process";
 import { readLinuxProcess } from "../pi-intercom/broker/pid.ts";
-import type { AgentProcessExit } from "./types.ts";
 import { hasErrorCode } from "./unknown.ts";
 
+interface AgentProcessExit {
+  readonly pid?: number;
+  readonly code: number | null;
+  readonly signal: NodeJS.Signals | null;
+  readonly at: number;
+}
+
 interface ChildWithPipedStdio {
   readonly stdout: ChildProcess["stdout"];
   readonly stderr: ChildProcess["stderr"];