@fitchmultz/pi-subagents 0.46.1 → 0.47.0

package/src/history/transcript-queries.ts

@@ -58,7 +58,7 @@ export class TranscriptQueries {
     boundary: Boundary,
     ids: readonly string[],
   ): readonly (readonly [string, boolean])[] {
-    const delivered: (readonly [string, boolean])[] = [];
+    const humans: (readonly [string, number])[] = [];
     const where = boundary.clauses.join(" AND ");
     for (const id of new Set(ids)) {
       const human = this.scope.store.get(
@@ -67,17 +67,23 @@ export class TranscriptQueries {
         id,
       );
       if (human) {
-        delivered.push([
-          id,
-          this.scope.store.get(
-            `SELECT rowid FROM entries WHERE ${where} AND start>? AND assistant_text=1 LIMIT 1`,
-            ...boundary.params,
-            number(human, "start"),
-          ) !== undefined,
-        ]);
+        humans.push([id, number(human, "start")]);
       }
     }
-    return delivered;
+    if (humans.length === 0) {
+      return [];
+    }
+    // One tail lookup answers every ID, without scanning before the earliest requested human.
+    const assistant = this.scope.store.get(
+      `SELECT start FROM entries WHERE ${where} AND start>? AND assistant_text=1 ORDER BY start DESC LIMIT 1`,
+      ...boundary.params,
+      Math.min(...humans.map(([, start]) => start)),
+    );
+    const assistantStart = assistant ? number(assistant, "start") : undefined;
+    return humans.map(([id, start]): readonly [string, boolean] => [
+      id,
+      assistantStart !== undefined && start < assistantStart,
+    ]);
   }
   private readMetadata(
     boundary: Boundary,

package/src/intercom/result-intercom.ts

@@ -1,5 +1,4 @@
 import type { ReadonlyInput } from "../shared/types/inputs.ts";
-import { copyDetails, copyResult } from "../extension/result-snapshot.ts";
 import { compactNestedResultChildren, formatNestedResultLines } from "./nested-result-tree.ts";
 export {
   compactNestedResultChildren,
@@ -13,7 +12,6 @@ import * as fs from "node:fs";
 import { formatRunAction } from "../shared/status-format.ts";
 import { SUBAGENT_CHILD_ENV, SUBAGENT_FANOUT_CHILD_ENV } from "../runs/shared/pi-args.ts";
 import type {
-  Details,
   SingleResult,
   SubagentResultIntercomChild,
   SubagentResultIntercomPayload,
@@ -308,104 +306,3 @@ export function buildSubagentResultIntercomPayload(
   };
   return { ...payload, message: formatSubagentResultIntercomMessage(payload) };
 }
-
-function stripSingleResultOutputs(result: ReadonlyInput<SingleResult>): SingleResult {
-  return {
-    ...copyResult(result),
-    messages: undefined,
-    finalOutput: undefined,
-    truncation: undefined,
-  };
-}
-
-export function stripDetailsOutputsForIntercomReceipt(
-  details: ReadonlyInput<Details>,
-  delivery?: Details["intercomDelivery"],
-): Details {
-  return {
-    ...copyDetails(details),
-    results: details.results.map(stripSingleResultOutputs),
-    ...(delivery ? { intercomDelivery: delivery } : {}),
-  };
-}
-
-function compactReceiptSummary(summary: string): string {
-  const withoutOutput = summary.split(/\n\nOutput:\n|\sOutput:\s/)[0] ?? summary;
-  const normalized = withoutOutput.replace(/\s+/g, " ").trim();
-  return normalized.length > 240 ? `${normalized.slice(0, 239)}…` : normalized;
-}
-
-function formatChildReferences(
-  children: readonly SubagentResultIntercomChild[],
-  field: "artifactPath" | "intercomTarget" | "sessionPath",
-  heading: string,
-): string[] {
-  const lines: string[] = [];
-  for (const child of children) {
-    const value = child[field];
-    if (typeof value === "string") {
-      lines.push(`- ${child.agent} [${child.status}]: ${value}`);
-    }
-  }
-  return lines.length > 0 ? [heading, ...lines] : [];
-}
-
-function formatReceiptReferences(payload: SubagentResultIntercomPayload): string[] {
-  const lines: string[] = [];
-  if (hasText(payload.resultPath)) {
-    lines.push(`Saved result (acceptance details when configured): ${payload.resultPath}`);
-  }
-  for (const child of payload.children) {
-    if (hasText(child.metadataPath)) {
-      lines.push(
-        `Result metadata (${child.agent}; acceptance details when configured): ${child.metadataPath}${fs.existsSync(child.metadataPath) ? "" : " (missing)"}`,
-      );
-    }
-  }
-  lines.push(
-    ...formatChildReferences(payload.children, "artifactPath", "Artifacts:"),
-    ...formatChildReferences(
-      payload.children,
-      "intercomTarget",
-      "Run intercom targets (may be inactive after completion):",
-    ),
-    ...formatChildReferences(payload.children, "sessionPath", "Sessions:"),
-  );
-  const nonCompleted = payload.children.filter((child) => child.status !== "completed");
-  if (nonCompleted.length > 0) {
-    lines.push("Non-completed children:");
-    for (const child of nonCompleted) {
-      lines.push(`- ${child.agent} [${child.status}]: ${compactReceiptSummary(child.summary)}`);
-    }
-  }
-  return lines;
-}
-
-export function formatSubagentResultReceipt(input: {
-  readonly mode: SubagentRunMode;
-  readonly runId: string;
-  readonly payload: SubagentResultIntercomPayload;
-}): string {
-  const counts = countStatuses(input.payload.children);
-  const modeLabel = {
-    single: "single subagent result",
-    parallel: "parallel subagent results",
-    chain: "chain subagent results",
-  }[input.mode];
-  const lines = [
-    `Delivered ${modeLabel} via intercom.`,
-    "Delivery: succeeded",
-    `Run: ${input.runId}`,
-    `Child outcome: ${input.payload.status}`,
-    `Children: ${formatStatusCounts(counts)}`,
-    ...(hasText(input.payload.error)
-      ? [
-          `Workflow ${input.payload.status === "paused" ? "paused" : "error"}: ${input.payload.error}`,
-        ]
-      : []),
-  ];
-
-  lines.push(...formatReceiptReferences(input.payload));
-  lines.push("Full grouped output was sent over intercom.");
-  return lines.join("\n");
-}

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

@@ -1,27 +1,51 @@
-import {
-  constants,
-  closeSync,
-  fstatSync,
-  openSync,
-  readFileSync,
-  realpathSync,
-  statSync,
-} from "node:fs";
+import { realpathSync, statSync } from "node:fs";
 import { isAbsolute } from "node:path";
 import { createSecureContext } from "node:tls";
+import { parseEnv } from "node:util";
 import { isUnknownArray } from "../shared/unknown.ts";
 import { BODY_LIMIT, object, label, fingerprint } from "./bridge-protocol.ts";
 import { launchPolicy, type LaunchPolicy } from "./bridge-launch-policy.ts";
+import { stateDirectory } from "./bridge-mailbox.ts";
+import { readBridgeFile } from "./bridge-files.ts";
 
 const MAX_CLIENTS = 64;
 
+export interface WakePolicy {
+  readonly envFile: string;
+  readonly url: string;
+  readonly key: string;
+}
+
+function wakePolicy(value: unknown): WakePolicy | undefined {
+  if (value === undefined) {
+    return;
+  }
+  const input = object(value, ["envFile"]);
+  const envFile = label(input.envFile, "wake credential file", 4096);
+  if (!isAbsolute(envFile)) {
+    throw new Error("Wake credential file must be absolute.");
+  }
+  const env = parseEnv(readBridgeFile(envFile, true, 16384).toString("utf8"));
+  const url = new URL(label(env.GROK_WAKE_WEBHOOK_URL, "wake webhook URL", 8192));
+  if (url.protocol !== "https:" || url.username !== "" || url.password !== "" || url.hash !== "") {
+    throw new Error("Wake webhook requires HTTPS without URL credentials or a fragment.");
+  }
+  return {
+    envFile,
+    url: url.href,
+    key: label(env.GROK_WAKE_WEBHOOK_KEY, "wake webhook key", 4096),
+  };
+}
+
 export interface Identity {
   readonly fingerprint256: string;
   readonly name: string;
   readonly cwd: string;
   readonly launch?: LaunchPolicy;
+  readonly wake?: WakePolicy;
 }
 export interface Config {
+  readonly stateDir?: string;
   readonly port: number;
   readonly ca: string;
   readonly cert: string;
@@ -30,26 +54,6 @@ export interface Config {
   readonly tls: { readonly ca: Buffer; readonly cert: Buffer; readonly key: Buffer };
 }
 
-function readFile(path: string, privateFile: boolean, limit: number): Buffer {
-  const fd = openSync(path, constants.O_RDONLY | constants.O_NOFOLLOW);
-  try {
-    const stat = fstatSync(fd);
-    if (!stat.isFile() || stat.size > limit) {
-      throw new Error("Configuration/TLS file must be a bounded regular file.");
-    }
-    if (privateFile && (stat.uid !== process.getuid?.() || (stat.mode & 0o777) !== 0o600)) {
-      throw new Error("Config and TLS key must be owned by the current user with mode 0600.");
-    }
-    const data = readFileSync(fd);
-    if (data.length > limit) {
-      throw new Error("Configuration/TLS file exceeds its size limit.");
-    }
-    return data;
-  } finally {
-    closeSync(fd);
-  }
-}
-
 function identities(value: unknown): Map<string, Identity> {
   if (!isUnknownArray(value) || value.length > MAX_CLIENTS) {
     throw new Error(`clients must be an array of at most ${MAX_CLIENTS} identities.`);
@@ -57,7 +61,7 @@ function identities(value: unknown): Map<string, Identity> {
   const clients = new Map<string, Identity>();
   const names = new Set<string>();
   for (const raw of value) {
-    const entry = object(raw, ["fingerprint256", "name", "cwd", "launch"]);
+    const entry = object(raw, ["fingerprint256", "name", "cwd", "launch", "wake"]);
     const fingerprint256 = fingerprint(entry.fingerprint256);
     const name = label(entry.name, "name", 128).trim();
     const cwd = label(entry.cwd, "cwd", 4096);
@@ -76,6 +80,7 @@ function identities(value: unknown): Map<string, Identity> {
       name,
       cwd: launch ? realpathSync(cwd) : cwd,
       launch,
+      wake: wakePolicy(entry.wake),
     });
     names.add(name.toLowerCase());
   }
@@ -84,9 +89,9 @@ function identities(value: unknown): Map<string, Identity> {
 
 export function loadConfig(path: string): Config {
   const raw: unknown = JSON.parse(
-    new TextDecoder("utf-8", { fatal: true }).decode(readFile(path, true, BODY_LIMIT)),
+    new TextDecoder("utf-8", { fatal: true }).decode(readBridgeFile(path, true, BODY_LIMIT)),
   );
-  const input = object(raw, ["port", "ca", "cert", "key", "clients"]);
+  const input = object(raw, ["port", "ca", "cert", "key", "clients", "stateDir"]);
   const port = input.port === undefined ? 9443 : input.port;
   if (typeof port !== "number" || !Number.isInteger(port) || port < 0 || port > 65535) {
     throw new Error("Invalid HTTPS port.");
@@ -99,16 +104,21 @@ export function loadConfig(path: string): Config {
   }
   const clients = identities(input.clients);
   const tls = {
-    ca: readFile(ca, false, 1024 * 1024),
-    cert: readFile(cert, false, 1024 * 1024),
-    key: readFile(key, true, 1024 * 1024),
+    ca: readBridgeFile(ca, false, 1024 * 1024),
+    cert: readBridgeFile(cert, false, 1024 * 1024),
+    key: readBridgeFile(key, true, 1024 * 1024),
   };
   createSecureContext({ ...tls, minVersion: "TLSv1.2" });
-  return { port, ca, cert, key, clients, tls };
+  const stateDir = stateDirectory(input.stateDir);
+  if (stateDir === undefined && [...clients.values()].some((identity) => identity.wake)) {
+    throw new Error("Wake delivery requires a durable stateDir.");
+  }
+  return { port, ca, cert, key, clients, tls, stateDir };
 }
 
 export function sameListener(next: Config, current: Config): boolean {
   return (
+    next.stateDir === current.stateDir &&
     next.port === current.port &&
     next.ca === current.ca &&
     next.cert === current.cert &&

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

@@ -0,0 +1,59 @@
+import {
+  constants,
+  closeSync,
+  fstatSync,
+  fsyncSync,
+  openSync,
+  readFileSync,
+  renameSync,
+  rmSync,
+  writeFileSync,
+} from "node:fs";
+import { dirname } from "node:path";
+import { randomUUID } from "node:crypto";
+
+export function readBridgeFile(path: string, privateFile: boolean, limit: number): Buffer {
+  const fd = openSync(path, constants.O_RDONLY | constants.O_NOFOLLOW);
+  try {
+    const stat = fstatSync(fd);
+    if (!stat.isFile() || stat.size > limit) {
+      throw new Error("Configuration/TLS file must be a bounded regular file.");
+    }
+    if (privateFile && (stat.uid !== process.getuid?.() || (stat.mode & 0o777) !== 0o600)) {
+      throw new Error("Config and TLS key must be owned by the current user with mode 0600.");
+    }
+    const data = readFileSync(fd);
+    if (data.length > limit) {
+      throw new Error("Configuration/TLS file exceeds its size limit.");
+    }
+    return data;
+  } finally {
+    closeSync(fd);
+  }
+}
+
+export function writeBridgeJson(path: string, value: object): void {
+  const temporary = `${path}.${randomUUID()}.tmp`;
+  const fd = openSync(
+    temporary,
+    constants.O_WRONLY | constants.O_CREAT | constants.O_EXCL | constants.O_NOFOLLOW,
+    0o600,
+  );
+  try {
+    try {
+      writeFileSync(fd, JSON.stringify(value));
+      fsyncSync(fd);
+    } finally {
+      closeSync(fd);
+    }
+    renameSync(temporary, path);
+    const directory = openSync(dirname(path), constants.O_RDONLY | constants.O_DIRECTORY);
+    try {
+      fsyncSync(directory);
+    } finally {
+      closeSync(directory);
+    }
+  } finally {
+    rmSync(temporary, { force: true });
+  }
+}