@fitchmultz/pi-subagents 0.49.1 → 0.50.0

package/src/runs/shared/child-execution-outcome.ts

@@ -1,103 +0,0 @@
-import type { ReadonlyInput } from "../../shared/types.ts";
-import type { ChildAttemptOptions, ChildAttemptResult } from "./child-attempt-types.ts";
-import { readFinalizationReport } from "./acceptance.ts";
-import { readStructuredOutput } from "./structured-output.ts";
-import { nonempty } from "./child-presence.ts";
-
-interface OutcomeInput {
-  readonly result: ReadonlyInput<ChildAttemptResult>;
-  readonly options: ReadonlyInput<ChildAttemptOptions>;
-  readonly code: number | null;
-  readonly signal?: NodeJS.Signals | null;
-  readonly spawnError?: Readonly<Error>;
-  readonly stopping: boolean;
-  readonly settledCleanup: boolean;
-  readonly cleanAssistantStop: boolean;
-  readonly assistantError?: string;
-}
-
-function processExitCode(input: OutcomeInput, drainedSuccess: boolean): number {
-  const result = input.result;
-  if (result.timedOut === true) {
-    return 124;
-  }
-  if (result.resourceLimitExceeded || result.terminalFailure === true) {
-    return 1;
-  }
-  if (result.interrupted === true || drainedSuccess) {
-    return 0;
-  }
-  return input.code ?? (input.stopping || nonempty(input.signal) ? 1 : 0);
-}
-
-function completedOutput(input: OutcomeInput): { completed: boolean; report: boolean } {
-  const runtime = input.options.nativeFinalization?.reportRuntime ?? input.options.reportRuntime;
-  const report = runtime
-    ? readFinalizationReport([...input.result.messages], runtime).output
-    : undefined;
-  const structured = input.options.structuredOutput
-    ? readStructuredOutput(input.options.structuredOutput)
-    : undefined;
-  return {
-    completed:
-      input.cleanAssistantStop ||
-      nonempty(report) ||
-      (structured !== undefined && !nonempty(structured.error)),
-    report: nonempty(report),
-  };
-}
-
-function drainedNativeSuccess(
-  input: OutcomeInput,
-  report: boolean,
-  error: string | undefined,
-): boolean {
-  return input.settledCleanup && (input.cleanAssistantStop || report) && !nonempty(error);
-}
-function processDiagnostic(code: number | null, stderr: string): string | undefined {
-  const diagnostics = stderr.trim();
-  if (code === 143) {
-    // Keep startup diagnostics without hiding the terminated process's actual exit status.
-    return `Child process exited with code 143.${diagnostics.length > 0 ? `\n${diagnostics}` : ""}`;
-  }
-  return diagnostics.length > 0 ? diagnostics : undefined;
-}
-function executionError(
-  input: OutcomeInput,
-  report: boolean,
-): { error?: string; drainedSuccess: boolean } {
-  let error =
-    input.result.error ?? (report ? undefined : input.assistantError) ?? input.spawnError?.message;
-  const drainedSuccess = drainedNativeSuccess(input, report, error);
-  if (
-    input.code !== 0 &&
-    !nonempty(error) &&
-    !drainedSuccess &&
-    input.result.interrupted !== true
-  ) {
-    error = processDiagnostic(input.code, input.result.stderr);
-  }
-  return { error, drainedSuccess };
-}
-
-/** Keep process cleanup distinct from completed native work and owner interruption. */
-export function childExecutionOutcome(
-  input: OutcomeInput,
-): Pick<ChildAttemptResult, "error" | "exitCode" | "terminalFailure"> {
-  const completion = completedOutput(input);
-  const { error, drainedSuccess } = executionError(input, completion.report);
-  const exitCode = processExitCode(input, drainedSuccess);
-  if (input.result.interrupted === true) {
-    return { error: undefined, exitCode, terminalFailure: input.result.terminalFailure };
-  }
-  if (exitCode === 0 && !nonempty(error) && !completion.completed) {
-    return {
-      error: input.options.nativeFinalization
-        ? "Native self-review boundary did not return a result."
-        : "Child exit was observed, but no completed assistant result was returned.",
-      exitCode: 1,
-      terminalFailure: true,
-    };
-  }
-  return { error, exitCode, terminalFailure: input.result.terminalFailure };
-}

package/src/runs/shared/child-invocation.ts

@@ -1,74 +0,0 @@
-import {
-  applyIntercomBridgeToAgent,
-  resolveIntercomBridge,
-} from "../../intercom/intercom-bridge.ts";
-import type { ReadonlyInput } from "../../shared/types.ts";
-import { applyThinkingSuffix, buildPiArgs } from "./pi-args.ts";
-import type { BuildPiArgsInput, BuildPiArgsResult } from "./pi-launch-input.ts";
-import {
-  buildClaudeCodeInvocation,
-  isClaudeCodeModel,
-  type ClaudeCodeInvocation,
-} from "./claude-code.ts";
-import { nativeFinalizationLaunch, type NativeFinalizationConfig } from "./native-finalization.ts";
-import { nonempty } from "./child-presence.ts";
-
-type ChildInvocationInput = ReadonlyInput<
-  Omit<BuildPiArgsInput, "baseArgs"> & { readonly nativeFinalization?: NativeFinalizationConfig }
->;
-export type ChildInvocation = BuildPiArgsResult & { claudeCodeInvocation?: ClaudeCodeInvocation };
-
-function bridgedInput(input: ChildInvocationInput): ChildInvocationInput {
-  if (!nonempty(input.orchestratorIntercomTarget)) {
-    return input;
-  }
-  const bridged = applyIntercomBridgeToAgent(
-    { systemPrompt: input.systemPrompt ?? "", tools: input.tools, extensions: input.extensions },
-    resolveIntercomBridge(input.orchestratorIntercomTarget),
-  );
-  return {
-    ...input,
-    systemPrompt: bridged.systemPrompt,
-    tools: bridged.tools,
-    extensions: bridged.extensions,
-  };
-}
-
-function finalizedPiInvocation(input: ChildInvocationInput): BuildPiArgsResult {
-  const built = buildPiArgs({
-    ...bridgedInput(input),
-    structuredOutput: input.nativeFinalization ? undefined : input.structuredOutput,
-    baseArgs: ["--mode", "json", "-p"],
-  });
-  if (!input.nativeFinalization) {
-    return built;
-  }
-  const runtime = nativeFinalizationLaunch(input.nativeFinalization);
-  built.args.push("--extension", runtime.extension);
-  Object.assign(built.env, runtime.env);
-  const tools = built.args.indexOf("--tools");
-  const names = tools >= 0 ? built.args.at(tools + 1) : undefined;
-  if (names !== undefined && !names.split(",").includes("structured_output")) {
-    built.args[tools + 1] = `${names},structured_output`;
-  }
-  return built;
-}
-
-export function buildChildInvocation(input: ChildInvocationInput): ChildInvocation {
-  const model = applyThinkingSuffix(input.model, input.thinking);
-  if (!nonempty(model) || !isClaudeCodeModel(model)) {
-    return finalizedPiInvocation(input);
-  }
-  const invocation = buildClaudeCodeInvocation({
-    ...input,
-    model,
-    systemPrompt: input.systemPrompt ?? undefined,
-    sessionName: input.intercomSessionName,
-    outputSchema: input.structuredOutput?.schema,
-  });
-  return {
-    args: [...invocation.args],
-    env: { ...invocation.env },
-    claudeCodeInvocation: invocation,
-  };
-}

package/src/runs/shared/child-message-validation.ts

@@ -1,233 +0,0 @@
-import type {
-  ObservedContent,
-  ObservedMessage,
-  ObservedUsage,
-} from "../../shared/types/messages.ts";
-import { isRecord as isObject } from "../../shared/unknown.ts";
-
-export function optionalString(value: unknown, label: string): string | undefined {
-  if (value === undefined) {
-    return;
-  }
-  if (typeof value !== "string") {
-    throw new SyntaxError(`Invalid ${label}`);
-  }
-  return value;
-}
-
-export function optionalNumber(value: unknown, label: string): number | undefined {
-  if (value === undefined) {
-    return;
-  }
-  if (typeof value !== "number") {
-    throw new SyntaxError(`Invalid ${label}`);
-  }
-  return value;
-}
-
-export function optionalBoolean(value: unknown, label: string): boolean | undefined {
-  if (value === undefined) {
-    return;
-  }
-  if (typeof value !== "boolean") {
-    throw new SyntaxError(`Invalid ${label}`);
-  }
-  return value;
-}
-
-export function requiredString(value: unknown, label: string): string {
-  const text = optionalString(value, label);
-  if (text === undefined) {
-    throw new SyntaxError(`Missing ${label}`);
-  }
-  return text;
-}
-
-function isObservedUsage(value: unknown): value is ObservedUsage {
-  if (!isObject(value)) {
-    return false;
-  }
-  for (const key of [
-    "input",
-    "output",
-    "cacheRead",
-    "cacheWrite",
-    "totalTokens",
-    "reasoning",
-    "cacheWrite1h",
-  ]) {
-    optionalNumber(value[key], `usage.${key}`);
-  }
-  if (value.cost !== undefined) {
-    if (!isObject(value.cost)) {
-      return false;
-    }
-    for (const key of ["input", "output", "cacheRead", "cacheWrite", "total"]) {
-      optionalNumber(value.cost[key], `cost.${key}`);
-    }
-  }
-  return true;
-}
-export function observedUsage(value: unknown): ObservedUsage | undefined {
-  if (value === undefined) {
-    return;
-  }
-  if (!isObservedUsage(value)) {
-    throw new SyntaxError("Invalid native usage");
-  }
-  return value;
-}
-
-function observedContent(value: unknown): ObservedContent {
-  if (!isObject(value)) {
-    throw new SyntaxError("Invalid native message content");
-  }
-  switch (value.type) {
-    case "text":
-      return {
-        ...value,
-        type: "text",
-        text: requiredString(value.text, "content.text"),
-        textSignature: optionalString(value.textSignature, "textSignature"),
-      };
-    case "thinking":
-      return {
-        ...value,
-        type: "thinking",
-        thinking: optionalString(value.thinking, "content.thinking") ?? "",
-        thinkingSignature: optionalString(value.thinkingSignature, "thinkingSignature"),
-      };
-    case "image":
-      return {
-        ...value,
-        type: "image",
-        data: optionalString(value.data, "image.data") ?? "",
-        mimeType: requiredString(value.mimeType, "image.mimeType"),
-      };
-    case "toolCall":
-      if (!isObject(value.arguments)) {
-        throw new SyntaxError("Invalid tool call arguments");
-      }
-      return {
-        ...value,
-        type: "toolCall",
-        id: requiredString(value.id, "toolCall.id"),
-        name: requiredString(value.name, "toolCall.name"),
-        arguments: value.arguments,
-      };
-    default:
-      throw new SyntaxError("Unsupported native message content");
-  }
-}
-
-function contentArray(value: unknown): ObservedContent[] {
-  if (!Array.isArray(value)) {
-    throw new SyntaxError("Invalid native message content array");
-  }
-  return value.map((part: unknown) => observedContent(part));
-}
-
-function assistant(value: Readonly<Record<string, unknown>>): ObservedMessage {
-  return {
-    ...value,
-    role: "assistant",
-    content: contentArray(value.content),
-    timestamp: optionalNumber(value.timestamp, "timestamp"),
-    api: optionalString(value.api, "api"),
-    provider: optionalString(value.provider, "provider"),
-    model: optionalString(value.model, "model"),
-    responseModel: optionalString(value.responseModel, "responseModel"),
-    responseId: optionalString(value.responseId, "responseId"),
-    usage: observedUsage(value.usage),
-    stopReason: optionalString(value.stopReason, "stopReason"),
-    errorMessage: optionalString(value.errorMessage, "errorMessage"),
-  };
-}
-
-function otherMessage(
-  value: Readonly<Record<string, unknown>>,
-  timestamp: number | undefined,
-): ObservedMessage {
-  switch (value.role) {
-    case "custom":
-      return {
-        ...value,
-        role: "custom",
-        timestamp,
-        customType: requiredString(value.customType, "customType"),
-        content: typeof value.content === "string" ? value.content : contentArray(value.content),
-        display: optionalBoolean(value.display, "display"),
-      };
-    case "bashExecution":
-      return {
-        ...value,
-        role: "bashExecution",
-        timestamp,
-        command: requiredString(value.command, "command"),
-        output: requiredString(value.output, "output"),
-        exitCode: optionalNumber(value.exitCode, "exitCode"),
-        cancelled: optionalBoolean(value.cancelled, "cancelled"),
-        truncated: optionalBoolean(value.truncated, "truncated"),
-        fullOutputPath: optionalString(value.fullOutputPath, "fullOutputPath"),
-        excludeFromContext: optionalBoolean(value.excludeFromContext, "excludeFromContext"),
-      };
-    case "branchSummary":
-      return {
-        ...value,
-        role: "branchSummary",
-        timestamp,
-        summary: requiredString(value.summary, "summary"),
-        fromId: value.fromId === null ? null : requiredString(value.fromId, "fromId"),
-      };
-    case "compactionSummary": {
-      const tokensBefore = optionalNumber(value.tokensBefore, "tokensBefore");
-      if (tokensBefore === undefined) {
-        throw new SyntaxError("Missing tokensBefore");
-      }
-      return {
-        ...value,
-        role: "compactionSummary",
-        timestamp,
-        summary: requiredString(value.summary, "summary"),
-        tokensBefore,
-      };
-    }
-    default:
-      throw new SyntaxError("Unsupported native message role");
-  }
-}
-
-export function observedMessage(value: unknown): ObservedMessage {
-  if (!isObject(value)) {
-    throw new SyntaxError("Invalid native message");
-  }
-  if (value.role === "assistant") {
-    return assistant(value);
-  }
-  const timestamp = optionalNumber(value.timestamp, "timestamp");
-  if (value.role === "toolResult") {
-    if (value.isError !== undefined && typeof value.isError !== "boolean") {
-      throw new SyntaxError("Invalid tool result isError");
-    }
-    return {
-      ...value,
-      role: "toolResult",
-      content: contentArray(value.content),
-      timestamp,
-      toolCallId: requiredString(value.toolCallId, "toolCallId"),
-      toolName: requiredString(value.toolName, "toolName"),
-      isError: value.isError,
-      observedExitCode: optionalNumber(value.observedExitCode, "observedExitCode"),
-      usage: observedUsage(value.usage),
-    };
-  }
-  if (value.role === "user" || value.role === "system") {
-    return {
-      ...value,
-      role: value.role,
-      timestamp,
-      content: typeof value.content === "string" ? value.content : contentArray(value.content),
-    };
-  }
-  return otherMessage(value, timestamp);
-}

package/src/runs/shared/child-native-accounting.ts

@@ -1,154 +0,0 @@
-import type { ReadonlyInput, Usage, UsageAccumulator } from "../../shared/types.ts";
-import { NativeJournal } from "../../shared/journal-reader.ts";
-import type { ChildAttemptResult, ChildObservation } from "./child-attempt-types.ts";
-import { readNativeUsage, nativeUsageCollector, type NativeUsageMetadata } from "./native-usage.ts";
-import { sumAttemptUsage } from "./model-fallback.ts";
-import { errorMessage as errorText } from "../../shared/unknown.ts";
-import { nonempty } from "./child-presence.ts";
-import { optionalString } from "./child-message-validation.ts";
-
-interface AccountingInput {
-  readonly file?: string;
-  readonly result: ReadonlyInput<ChildAttemptResult>;
-  readonly baseline: Readonly<ReadonlySet<string>>;
-  readonly acceptedEntries: Readonly<ReadonlyMap<string, NativeUsageMetadata>>;
-  readonly reference: (entry: NativeUsageMetadata) => ChildObservation | undefined;
-  readonly observations: () => readonly ChildObservation[];
-}
-export interface NativeAccountingResult {
-  readonly publishedIds: Readonly<ReadonlySet<string>>;
-  readonly accounting: NonNullable<ChildAttemptResult["accounting"]>;
-  readonly usage?: UsageAccumulator;
-  readonly segmentUsage?: readonly Usage[];
-  readonly nativeSessionId?: string;
-  readonly terminalEntryId?: string;
-  readonly terminalLeafId?: string | null;
-  readonly effectiveConfiguration?: ChildAttemptResult["effectiveConfiguration"];
-}
-
-function verifyObservedCommits(
-  observations: readonly ChildObservation[],
-  publishedIds: Readonly<ReadonlySet<string>>,
-): void {
-  const missing = observations.some((item) => {
-    if (!item.message) {
-      return false;
-    }
-    const billable =
-      item.message.role === "assistant" ||
-      (item.message.role === "toolResult" && item.message.usage !== undefined);
-    return billable && (item.nativeEntryId === undefined || !publishedIds.has(item.nativeEntryId));
-  });
-  if (missing) {
-    throw new Error(
-      "Finalized message usage has no verified native commit; its reported usage and audit remain available.",
-    );
-  }
-}
-
-function acceptedTotals(input: AccountingInput): readonly Usage[] | undefined {
-  if (!nonempty(input.result.nativeSessionId) || input.acceptedEntries.size === 0) {
-    return;
-  }
-  const accepted = nativeUsageCollector(
-    input.result.nativeSessionId,
-    input.baseline,
-    input.result.finalization?.map((segment) => segment.event.lastEntryId),
-  );
-  for (const entry of input.acceptedEntries.values()) {
-    accepted.append(entry);
-  }
-  return accepted.totals;
-}
-
-/** Publication, not message_end, authorizes complete native accounting. */
-export function accountNativeChild(input: AccountingInput): NativeAccountingResult {
-  const publishedIds = new Set<string>();
-  let nativeSessionId = input.result.nativeSessionId;
-  let terminalEntryId = input.result.terminalEntryId;
-  let accounting: NonNullable<ChildAttemptResult["accounting"]> = input.result.accounting ?? {
-    state: "complete",
-  };
-  let usage: UsageAccumulator | undefined;
-  let segmentUsage: readonly Usage[] | undefined;
-  try {
-    const native = readNativeUsage(
-      input.file,
-      input.baseline,
-      input.result.finalization?.map((segment) => segment.event.lastEntryId),
-      {
-        onEntry: (entry) => {
-          if (entry.type === "message") {
-            publishedIds.add(entry.id);
-            if (!input.baseline.has(entry.id)) {
-              input.reference(entry);
-            }
-          }
-        },
-        onBoundary: (boundary) => {
-          nativeSessionId = boundary.sessionId;
-          terminalEntryId = boundary.lastEntryId;
-        },
-      },
-    );
-    const totals = native ?? acceptedTotals(input);
-    if (totals) {
-      if (native) {
-        verifyObservedCommits(input.observations(), publishedIds);
-      }
-      accounting = { state: "complete" };
-      const total = sumAttemptUsage(
-        totals.map((item) => ({
-          model: input.result.model ?? "default",
-          success: true,
-          usage: item,
-        })),
-      );
-      usage = { ...total, contributions: total.contributions?.slice() };
-      segmentUsage = totals;
-    }
-  } catch (error) {
-    accounting = {
-      state: "incomplete",
-      error: `Cannot read finalized native usage: ${errorText(error)}`,
-    };
-  }
-  const selection = terminalSelection(input.file, input.result, terminalEntryId, accounting);
-  return { ...selection, publishedIds, nativeSessionId, usage, segmentUsage };
-}
-
-function terminalSelection(
-  file: string | undefined,
-  result: ReadonlyInput<ChildAttemptResult>,
-  terminalEntryId: string | undefined,
-  accounting: Readonly<NonNullable<ChildAttemptResult["accounting"]>>,
-): Pick<
-  NativeAccountingResult,
-  "accounting" | "effectiveConfiguration" | "terminalEntryId" | "terminalLeafId"
-> {
-  let selectedEntryId = terminalEntryId;
-  let selectionAccounting = accounting;
-  let terminalLeafId = result.terminalLeafId;
-  let effectiveConfiguration = result.effectiveConfiguration;
-  if (effectiveConfiguration || !nonempty(file)) {
-    return { accounting, effectiveConfiguration, terminalEntryId, terminalLeafId };
-  }
-  try {
-    const journal = new NativeJournal(file, "inspect", true);
-    const terminal = journal.records.findLast((record) => record.value.type !== "session");
-    selectedEntryId ??= optionalString(terminal?.value.id, "terminal native ID");
-    terminalLeafId ??= selectedEntryId;
-    effectiveConfiguration = journal.configuration(undefined, terminalLeafId);
-  } catch (error) {
-    selectionAccounting = {
-      state: "incomplete",
-      error: accounting.error ?? `Cannot capture terminal native selection: ${errorText(error)}`,
-    };
-  }
-  return {
-    accounting: selectionAccounting,
-    effectiveConfiguration,
-    terminalEntryId: selectedEntryId,
-    terminalLeafId,
-  };
-}

package/src/runs/shared/child-native-observation.ts

@@ -1,79 +0,0 @@
-import * as fs from "node:fs";
-import type { ExtensionAPI, ExtensionContext, SessionEntry } from "@earendil-works/pi-coding-agent";
-import { SessionEntryCursor } from "../../shared/session-entries.ts";
-import { nonempty } from "./child-presence.ts";
-
-function entryObservation(entry: SessionEntry): Readonly<Record<string, unknown>> {
-  const message = entry.type === "message" ? entry.message : undefined;
-  const usage =
-    entry.type === "usage" || entry.type === "compaction" || entry.type === "branch_summary"
-      ? entry.usage
-      : undefined;
-  return {
-    id: entry.id,
-    type: entry.type,
-    parentId: entry.parentId,
-    ...("checkpoint" in entry ? { checkpoint: entry.checkpoint } : {}),
-    ...(usage !== undefined ? { usage } : {}),
-    ...(entry.type === "usage" ? { provider: entry.provider, model: entry.model } : {}),
-    ...(message ? { message: messageObservation(message) } : {}),
-  };
-}
-function messageObservation(
-  message: Extract<SessionEntry, { type: "message" }>["message"],
-): Readonly<Record<string, unknown>> {
-  return {
-    role: message.role,
-    timestamp: message.timestamp,
-    ...("usage" in message ? { usage: message.usage } : {}),
-    ...(message.role === "assistant"
-      ? { provider: message.provider, model: message.model, responseModel: message.responseModel }
-      : {}),
-    ...("toolCallId" in message ? { toolCallId: message.toolCallId } : {}),
-  };
-}
-
-/** turn_end follows native append; message_end alone is never a commit receipt. */
-export class ChildNativeObservation {
-  private readonly cursor = new SessionEntryCursor();
-  private previousIds = new Set<string>();
-  private observedMessages = 0;
-  start(ctx: ExtensionContext): void {
-    this.cursor.reset();
-    this.observedMessages = 0;
-    const { entries } = this.cursor.read(ctx.sessionManager);
-    const baseline = process.env.PI_SUBAGENT_NATIVE_BASELINE_COUNT;
-    if (nonempty(baseline) && /^\d+$/.test(baseline)) {
-      process.stdout.write(
-        `${JSON.stringify({ type: "subagent.native_baseline", sessionId: ctx.sessionManager.getSessionId(), entryIds: entries.slice(0, Number(baseline)).map((entry) => entry.id) })}\n`,
-      );
-    }
-    const file = ctx.sessionManager.getSessionFile();
-    const persisted = nonempty(file) && fs.existsSync(file);
-    this.previousIds = persisted ? new Set(entries.map((entry) => entry.id)) : new Set();
-    if (!persisted) {
-      this.cursor.reset();
-    }
-  }
-  message(role: string): void {
-    if (["assistant", "user", "toolResult"].includes(role)) {
-      this.observedMessages++;
-    }
-  }
-  publish(ctx: ExtensionContext, boundary: string, pi: ExtensionAPI): void {
-    if (process.env.PI_SUBAGENT_CHILD !== "1") {
-      return;
-    }
-    const entries: Readonly<Record<string, unknown>>[] = [];
-    for (const entry of this.cursor.read(ctx.sessionManager).entries) {
-      if (!this.previousIds.has(entry.id)) {
-        this.previousIds.add(entry.id);
-        entries.push(entryObservation(entry));
-      }
-    }
-    const sessionFile = ctx.sessionManager.getSessionFile();
-    process.stdout.write(
-      `${JSON.stringify({ type: "subagent.native", boundary, entries, sessionId: ctx.sessionManager.getSessionId(), sessionFile, leafId: ctx.sessionManager.getLeafId(), persisted: nonempty(sessionFile) && fs.existsSync(sessionFile), messageCount: this.observedMessages, configuration: { ...(ctx.model ? { model: `${ctx.model.provider}/${ctx.model.id}` } : {}), thinking: pi.getThinkingLevel() } })}\n`,
-    );
-  }
-}