@fitchmultz/pi-subagents 0.49.0 → 0.50.0

package/src/agent/launch.ts

@@ -0,0 +1,112 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { randomUUID } from "node:crypto";
+import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
+import type { ThinkingLevel } from "@earendil-works/pi-agent-core";
+import type { Launch, DelegateInput } from "./contracts.ts";
+import { loadSDK, packageRoot, runtimeEntry } from "./host.ts";
+import { runDirectory, write } from "./storage.ts";
+
+function selectedModel(input: DelegateInput, context: ExtensionContext) {
+  if (input.model === undefined) {
+    if (!context.model) {
+      throw new Error("No selected model; no fallback was used.");
+    }
+    return context.model;
+  }
+  const slash = input.model.indexOf("/");
+  if (slash < 1) {
+    throw new Error("model must be an exact provider/model ID.");
+  }
+  const model = context.modelRegistry.find(
+    input.model.slice(0, slash),
+    input.model.slice(slash + 1),
+  );
+  if (!model) {
+    throw new Error(`Model ${input.model} is unavailable; no fallback was used.`);
+  }
+  return model;
+}
+function targetTrust(
+  sdk: Awaited<ReturnType<typeof loadSDK>>,
+  cwd: string,
+  context: ExtensionContext,
+  agentDir: string,
+): boolean {
+  if (fs.realpathSync(cwd) === fs.realpathSync(context.cwd)) {
+    return context.isProjectTrusted();
+  }
+  if (!sdk.hasTrustRequiringProjectResources(cwd)) {
+    return true;
+  }
+  const remembered = new sdk.ProjectTrustStore(agentDir).get(cwd);
+  if (remembered !== null) {
+    return remembered;
+  }
+  // Resolve another project's global policy without loading its untrusted settings.
+  const settings = sdk.SettingsManager.create(cwd, agentDir, { projectTrusted: false });
+  return settings.getDefaultProjectTrust() === "always";
+}
+export async function prepareLaunch(options: {
+  input: DelegateInput;
+  context: ExtensionContext;
+  base: string;
+  owner: string;
+  agentDir: string;
+  thinking: ThinkingLevel;
+  executionCwd: string;
+}): Promise<Launch> {
+  const { input, context, base, owner, agentDir, thinking } = options;
+  const sdkRoot = packageRoot();
+  const sdk = await loadSDK(sdkRoot);
+  const cwd = path.resolve(options.executionCwd, input.cwd ?? ".");
+  if (!fs.statSync(cwd).isDirectory()) {
+    throw new Error("Delegation cwd is not a directory.");
+  }
+  const model = selectedModel(input, context);
+  const trusted = targetTrust(sdk, cwd, context, agentDir);
+  const id = randomUUID();
+  const directory = runDirectory(base, id);
+  fs.mkdirSync(directory, { mode: 0o700 });
+  const manager = sdk.SessionManager.create(cwd, directory);
+  const sessionFile = manager.getSessionFile();
+  const header = manager.getHeader();
+  if (sessionFile === undefined || !header) {
+    throw new Error("Native session did not allocate a durable identity.");
+  }
+  const inherited = input.context === "fork" ? context.sessionManager.getBranch() : [];
+  const savedHeader =
+    input.context === "fork"
+      ? { ...header, parentSession: context.sessionManager.getSessionFile() }
+      : header;
+  // Preserve the full native branch: no semantic tool filter or canned body.
+  fs.writeFileSync(
+    sessionFile,
+    [savedHeader, ...inherited].map((entry) => JSON.stringify(entry)).join("\n") + "\n",
+    { flag: "wx", mode: 0o600 },
+  );
+  const launch: Launch = {
+    version: 1,
+    id,
+    rootId: id,
+    owner,
+    cwd,
+    agentDir,
+    sdk: sdkRoot,
+    entry: runtimeEntry(),
+    sessionFile,
+    sessionId: manager.getSessionId(),
+    prompt: input.prompt,
+    context: input.context ?? "fresh",
+    provider: model.provider,
+    model: model.id,
+    thinking,
+    trusted,
+    name: input.name,
+    createdAt: Date.now(),
+  };
+  // Retain even unpublished native journals on failure, including full fork evidence.
+  // Inventory admits only directories with a canonical launch.json.
+  write(path.join(directory, "launch.json"), launch, true);
+  return launch;
+}

package/src/agent/legacy.ts

@@ -0,0 +1,167 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
+import { journalStamp } from "../shared/native-journal.ts";
+import { receiptId } from "./receipts.ts";
+import { resolveTempRootDir } from "../shared/types.ts";
+import { isRecord } from "../shared/unknown.ts";
+import { hold, release, isHeld } from "./notifications.ts";
+import { missing } from "./storage.ts";
+
+interface LegacyInput {
+  file: string;
+  raw: string;
+  stamp: string;
+  id: string;
+  key: string;
+  owner: string;
+  single: boolean;
+}
+function legacyInput(file: string, owner: string): LegacyInput | undefined {
+  const stat = fs.lstatSync(file, { bigint: true });
+  if (!stat.isFile() || stat.isSymbolicLink()) {
+    return;
+  }
+  const raw = fs.readFileSync(file, "utf8");
+  const data: unknown = JSON.parse(raw);
+  if (!isRecord(data) || data.sessionId !== owner) {
+    return;
+  }
+  const id = typeof data.runId === "string" ? data.runId : data.id;
+  if (typeof id !== "string" || path.basename(file, ".json") !== id) {
+    return;
+  }
+  const legacy = `legacy:${id}:${typeof data.timestamp === "number" ? data.timestamp : "unknown"}`;
+  const completionId = typeof data.completionId === "string" ? data.completionId : legacy;
+  return {
+    file,
+    raw,
+    stamp: journalStamp(stat),
+    id,
+    key: `completion:${completionId}`,
+    owner,
+    single: data.mode === "single",
+  };
+}
+function legacyCompletion(details: unknown, input: LegacyInput): boolean {
+  if (!isRecord(details)) {
+    return false;
+  }
+  const value = details.completion ?? details.subagentCompletion;
+  if (!isRecord(value) || value.runId !== input.id) {
+    return false;
+  }
+  if (value.ownerSessionId !== undefined && value.ownerSessionId !== input.owner) {
+    return false;
+  }
+  return completionKey(value, input.key);
+}
+function completionKey(value: Record<string, unknown>, key: string): boolean {
+  return (
+    value.key === key ||
+    `completion:${typeof value.completionId === "string" ? value.completionId : ""}` === key ||
+    (key.startsWith("completion:legacy:") && value.completionId === undefined)
+  );
+}
+function legacyWait(message: unknown, input: LegacyInput): boolean {
+  if (
+    !isRecord(message) ||
+    message.role !== "toolResult" ||
+    message.isError === true ||
+    !isRecord(message.details)
+  ) {
+    return false;
+  }
+  if (
+    !["delegate", "subagent", "agent_runs"].includes(
+      typeof message.toolName === "string" ? message.toolName : "",
+    )
+  ) {
+    return false;
+  }
+  return completedWait(message.details.wait, input);
+}
+function completedWait(wait: unknown, input: LegacyInput): boolean {
+  return (
+    isRecord(wait) &&
+    wait.status === "completed" &&
+    wait.runId === input.id &&
+    (wait.index === undefined || (input.single && wait.index === 0))
+  );
+}
+function receipt(body: unknown, input: LegacyInput): boolean {
+  if (!isRecord(body)) {
+    return false;
+  }
+  if (body.type === "custom_message") {
+    return legacyCompletion(body.details, input);
+  }
+  return body.type === "message" && legacyWait(body.message, input);
+}
+function published(ctx: ExtensionContext, input: LegacyInput): boolean {
+  return (
+    receiptId(ctx.sessionManager.getSessionFile(), input.owner, (body) => receipt(body, input)) !==
+    undefined
+  );
+}
+function deliver(pi: ExtensionAPI, ctx: ExtensionContext, input: LegacyInput): void {
+  const identity = `legacy:${input.id}:${input.key}`;
+  if (published(ctx, input)) {
+    release(input.owner, identity);
+    // Retire only the unchanged recovery input whose actual native receipt exists.
+    if (
+      journalStamp(fs.lstatSync(input.file, { bigint: true })) === input.stamp &&
+      fs.readFileSync(input.file, "utf8") === input.raw
+    ) {
+      fs.unlinkSync(input.file);
+    }
+    return;
+  }
+  if (isHeld(input.owner, identity)) {
+    return;
+  }
+  hold(input.owner, identity);
+  try {
+    pi.sendMessage(
+      {
+        customType: "subagent-notify",
+        display: true,
+        // Full saved bytes, not a replacement summary. No owner/run record is invented.
+        content: input.raw,
+        details: { completion: { runId: input.id, key: input.key, ownerSessionId: input.owner } },
+      },
+      { triggerTurn: true, deliverAs: "followUp" },
+    );
+  } catch (error) {
+    release(input.owner, identity);
+    throw error;
+  }
+}
+export function notifyLegacy(pi: ExtensionAPI, ctx: ExtensionContext): void {
+  const root = resolveTempRootDir();
+  const directory = path.join(root, "async-subagent-results");
+  let names: string[];
+  try {
+    for (const candidate of [root, directory]) {
+      const stat = fs.lstatSync(candidate);
+      if (!stat.isDirectory() || stat.isSymbolicLink()) {
+        throw new Error(`Unsafe legacy recovery directory: ${candidate}`);
+      }
+    }
+    names = fs.readdirSync(directory);
+  } catch (error) {
+    if (missing(error)) {
+      return;
+    }
+    throw error;
+  }
+  for (const name of names) {
+    if (!name.endsWith(".json")) {
+      continue;
+    }
+    const input = legacyInput(path.join(directory, name), ctx.sessionManager.getSessionId());
+    if (input) {
+      deliver(pi, ctx, input);
+    }
+  }
+}

package/src/agent/notifications.ts

@@ -0,0 +1,131 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
+import { receiptId } from "./receipts.ts";
+import { readOutputPage } from "../shared/output-page.ts";
+import { isRecord } from "../shared/unknown.ts";
+import type { Launch, Result } from "./contracts.ts";
+import { launchAt, list, runDirectory } from "./storage.ts";
+import { readResult } from "./usage.ts";
+
+function queuedAdmissions(): Set<string> {
+  const store = globalThis as Record<string, unknown>;
+  const existing = store.__pi_single_agent_admissions__;
+  if (existing instanceof Set) {
+    const values: Set<unknown> = existing;
+    const strings = [...values].filter((value): value is string => typeof value === "string");
+    if (strings.length === values.size) {
+      // Keep one live queue identity across native extension reloads.
+      // oxlint-disable-next-line typescript/no-unsafe-return
+      return existing;
+    }
+  }
+  const queued = new Set<string>();
+  store.__pi_single_agent_admissions__ = queued;
+  return queued;
+}
+const admissions = queuedAdmissions();
+export function hold(owner: string, id: string): boolean {
+  const key = `${owner}/${id}`;
+  if (admissions.has(key)) {
+    return false;
+  }
+  admissions.add(key);
+  return true;
+}
+export function release(owner: string, id: string): void {
+  admissions.delete(`${owner}/${id}`);
+}
+export function isHeld(owner: string, id: string): boolean {
+  return admissions.has(`${owner}/${id}`);
+}
+export function settle(owner: string, pending: boolean): void {
+  if (pending) {
+    return;
+  }
+  for (const key of admissions) {
+    if (key.startsWith(`${owner}/`)) {
+      admissions.delete(key);
+    }
+  }
+}
+function matches(value: unknown, launch: Launch): boolean {
+  return (
+    isRecord(value) &&
+    value.owner === launch.owner &&
+    value.id === launch.id &&
+    value.completed === true
+  );
+}
+function toolReceipt(message: unknown, launch: Launch): boolean {
+  if (!isRecord(message) || message.role !== "toolResult") {
+    return false;
+  }
+  return (
+    (message.toolName === "delegate" || message.toolName === "agent_runs") &&
+    isRecord(message.details) &&
+    message.details.receivedResult === true &&
+    matches(message.details, launch)
+  );
+}
+function receipt(body: unknown, launch: Launch): boolean {
+  if (!isRecord(body)) {
+    return false;
+  }
+  if (body.type === "custom_message" && body.customType === "agent-completion") {
+    return matches(body.details, launch);
+  }
+  return body.type === "message" && toolReceipt(body.message, launch);
+}
+export function published(ctx: ExtensionContext, launch: Launch): string | undefined {
+  return receiptId(ctx.sessionManager.getSessionFile(), launch.owner, (body) =>
+    receipt(body, launch),
+  );
+}
+function send(pi: ExtensionAPI, base: string, launch: Launch, result: Result): void {
+  const file = path.join(runDirectory(base, launch.id), "output.txt");
+  const page = fs.existsSync(file) ? readOutputPage(file, { offset: 0, length: 32768 }) : undefined;
+  const more =
+    page?.nextOffset !== undefined
+      ? `\n[More output: agent_runs inspect id=${launch.id} offset=${page.nextOffset}; ${page.size} bytes total.]`
+      : "";
+  hold(launch.owner, launch.id);
+  try {
+    pi.sendMessage(
+      {
+        customType: "agent-completion",
+        display: true,
+        content: `Agent run ${launch.id}: ${result.status}. ${result.error ?? ""}\n${page?.text ?? ""}${more}\nNative journal: ${launch.sessionFile}`,
+        details: {
+          owner: launch.owner,
+          id: launch.id,
+          completed: true,
+          result,
+          outputFile: file,
+          page,
+        },
+      },
+      { triggerTurn: true, deliverAs: "followUp" },
+    );
+  } catch (error) {
+    admissions.delete(`${launch.owner}/${launch.id}`);
+    throw error;
+  }
+}
+export function notify(pi: ExtensionAPI, ctx: ExtensionContext, base: string, owner: string): void {
+  for (const id of list(base)) {
+    const launch = launchAt(base, id, owner);
+    const result = readResult(base, launch);
+    if (!result) {
+      continue;
+    }
+    const key = `${owner}/${id}`;
+    if (published(ctx, launch) !== undefined) {
+      admissions.delete(key);
+      continue;
+    }
+    if (!admissions.has(key)) {
+      send(pi, base, launch, result);
+    }
+  }
+}

package/src/agent/observe-screen.ts

@@ -0,0 +1,167 @@
+import { rawKeyHint, type KeybindingsManager, type Theme } from "@earendil-works/pi-coding-agent";
+import { sliceByColumn, truncateToWidth, visibleWidth, type TUI } from "@earendil-works/pi-tui";
+import { type JournalTail, plainText } from "./journal-tail.ts";
+
+export type ObserverRow = {
+  id: string;
+  name: string;
+  status: string;
+  live: boolean;
+  createdAt: number;
+};
+export type Watch = { tail: JournalTail; file: string; id: string; inherited: boolean };
+export interface ObserverData {
+  inventory: () => ObserverRow[];
+  row: (id: string) => ObserverRow | undefined;
+  status: () => string;
+  error: () => string;
+  watch: (id: string) => Watch;
+}
+export class ObserverScreen {
+  private selected: string;
+  private watching?: Watch;
+  private failure = "";
+  private readonly data: ObserverData;
+  private readonly tui: TUI;
+  private readonly theme: Theme;
+  private readonly keys: KeybindingsManager;
+  private readonly done: () => void;
+  private readonly timer: NodeJS.Timeout;
+  constructor(options: {
+    data: ObserverData;
+    tui: TUI;
+    theme: Theme;
+    keys: KeybindingsManager;
+    done: () => void;
+    selected: string;
+  }) {
+    this.data = options.data;
+    this.tui = options.tui;
+    this.theme = options.theme;
+    this.keys = options.keys;
+    this.done = options.done;
+    this.selected = options.selected;
+    if (this.selected.length > 0) {
+      this.open(this.selected);
+    }
+    this.timer = setInterval(() => this.update(), 250);
+    this.timer.unref();
+    this.update();
+  }
+  private open(id: string): void {
+    try {
+      this.watching = this.data.watch(id);
+      this.selected = this.watching.id;
+      this.failure = "";
+    } catch (error) {
+      this.failure = error instanceof Error ? plainText(error.message) : "Journal unavailable.";
+    }
+  }
+  update(): void {
+    this.watching?.tail.poll();
+    this.tui.requestRender();
+  }
+  private move(data: string): void {
+    const rows = this.data.inventory();
+    const index = Math.max(
+      0,
+      rows.findIndex((row) => row.id === this.selected),
+    );
+    if (this.keys.matches(data, "tui.select.confirm")) {
+      const row = rows.at(index);
+      if (row) {
+        this.open(row.id);
+      }
+    } else if (this.keys.matches(data, "tui.select.down")) {
+      this.selected = rows[Math.min(rows.length - 1, index + 1)]?.id ?? "";
+    } else if (this.keys.matches(data, "tui.select.up")) {
+      this.selected = rows[Math.max(0, index - 1)]?.id ?? "";
+    }
+  }
+  handleInput(data: string): void {
+    if (this.keys.matches(data, "tui.select.cancel")) {
+      if (this.watching) {
+        this.watching = undefined;
+        this.failure = "";
+      } else {
+        this.done();
+      }
+    } else if (!this.watching) {
+      this.move(data);
+    }
+    this.update();
+  }
+  private listLines(height: number): string[] {
+    const rows = this.data.inventory();
+    const index = Math.max(
+      0,
+      rows.findIndex((row) => row.id === this.selected),
+    );
+    const size = Math.max(1, height - 1);
+    const start = Math.max(0, index - size + 1);
+    const page = rows.slice(start, start + size);
+    return rows.length === 0
+      ? ["No child runs in this native parent session."]
+      : [
+          `Runs ${start + 1}–${start + page.length} of ${rows.length} · active first`,
+          ...page.map(
+            (row, i) =>
+              `${start + i === index ? ">" : " "} ${row.id.slice(0, 8)} ${row.status} · ${row.name}`,
+          ),
+        ];
+  }
+  private journalPath(width: number, file: string): string {
+    const text = plainText(file.slice(-2048), 2048);
+    const size = visibleWidth(text);
+    const room = Math.max(0, width - 1);
+    return size > width ? `…${sliceByColumn(text, size - room, room)}` : text;
+  }
+  private watchLines(height: number, watch: Watch, width: number): string[] {
+    const row = this.data.row(this.selected);
+    return [
+      `${this.selected.slice(0, 8)} ${row?.status ?? "checking"} · ${row?.name ?? this.selected}`,
+      this.journalPath(width, watch.file),
+      ...(watch.inherited ? ["Fork context: includes inherited parent activity."] : []),
+      ...watch.tail.lines.slice(-Math.max(1, height - 3)),
+      watch.tail.notice,
+    ];
+  }
+  render(width: number): string[] {
+    const height = Math.max(1, Math.min(16, this.tui.terminal.rows - 9));
+    const content = this.watching
+      ? this.watchLines(height, this.watching, width)
+      : this.listLines(height);
+    const cancel = this.keys.getKeys("tui.select.cancel").join("/");
+    const hint = this.watching
+      ? `${rawKeyHint(cancel, "back")} · native published entries, not token deltas`
+      : [
+          rawKeyHint(
+            [...this.keys.getKeys("tui.select.up"), ...this.keys.getKeys("tui.select.down")].join(
+              "/",
+            ),
+            "select",
+          ),
+          rawKeyHint(this.keys.getKeys("tui.select.confirm").join("/"), "watch"),
+          rawKeyHint(cancel, "close"),
+        ].join(" · ");
+    const error = this.failure.length > 0 ? this.failure : this.data.error();
+    return [
+      this.theme.fg(
+        "accent",
+        this.watching?.inherited === true
+          ? "Agents · read-only · fork context"
+          : "Agents · read-only",
+      ),
+      this.theme.fg("muted", this.data.status()),
+      ...content,
+      this.theme.fg("error", error),
+      this.theme.fg("dim", hint),
+    ].map((line) => truncateToWidth(line, width));
+  }
+  invalidate(): void {
+    this.tui.requestRender();
+  }
+  dispose(): void {
+    clearInterval(this.timer);
+  }
+}