@fitchmultz/pi-subagents 0.49.1 → 0.50.0

package/dist/runs/shared/child-attempt.js

@@ -1,340 +0,0 @@
-import { spawn } from "node:child_process";
-import { addAbortListener } from "node:events";
-import { getSubagentDepthEnv, } from "../../shared/types.js";
-import { attachChildProcessLifecycle } from "../../shared/post-exit-stdio-guard.js";
-import { findLatestSessionFile, formatResourceLimitExceeded } from "../../shared/utils.js";
-import { resolveExecutionOutcome } from "./acceptance.js";
-import { snapshotNativeBaseline } from "./native-usage.js";
-import { getPiSpawnCommand } from "./pi-spawn.js";
-import { ChildObservationSpool } from "./child-observation-spool.js";
-import { ChildStreamObserver } from "./child-stream-observer.js";
-import { ChildEventObserver } from "./child-event-observer.js";
-import { accountNativeChild } from "./child-native-accounting.js";
-import { childExecutionOutcome } from "./child-execution-outcome.js";
-import { errorMessage as errorText } from "../../shared/unknown.js";
-import { nonempty } from "./child-presence.js";
-export { buildChildInvocation } from "./child-invocation.js";
-function initialResult(model) {
-    return {
-        stderr: "",
-        exitCode: 0,
-        messages: [],
-        model,
-        usage: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, cost: 0, turns: 0 },
-        finalOutput: "",
-        observedCompletedMutation: false,
-        durationMs: 0,
-    };
-}
-function nativeSessionFile(options) {
-    if (options.claudeCodeInvocation) {
-        return;
-    }
-    const index = options.args.indexOf("--session-dir");
-    const directory = index >= 0 ? options.args.at(index + 1) : undefined;
-    return (options.sessionFile ??
-        (nonempty(directory) ? (findLatestSessionFile(directory) ?? undefined) : undefined));
-}
-/** One process-group owner; event accounting, observation retention and native review are separate. */
-class ChildAttemptRunner {
-    options;
-    completion = Promise.withResolvers();
-    startedAt = Date.now();
-    spool;
-    events;
-    stream;
-    lifecycle;
-    resourceTimer;
-    abortListener;
-    interruptListener;
-    receiverFailed = false;
-    settled = false;
-    pid;
-    constructor(options, baseline, spool) {
-        this.options = options;
-        this.spool = spool;
-        const command = options.claudeCodeInvocation ?? getPiSpawnCommand(options.args);
-        const child = spawn(command.command, [...command.args], {
-            cwd: options.cwd,
-            env: {
-                ...process.env,
-                ...options.env,
-                ...getSubagentDepthEnv(options.maxSubagentDepth),
-                PI_SUBAGENT_NATIVE_BASELINE_COUNT: baseline.legacy ? String(baseline.entryCount) : "",
-            },
-            stdio: ["ignore", "pipe", "pipe"],
-            detached: true,
-        });
-        this.pid = child.pid;
-        this.lifecycle = attachChildProcessLifecycle(child);
-        this.events = new ChildEventObserver(options, baseline, {
-            observeLifecycle: (type) => this.lifecycle.observeEvent(type),
-            stopping: () => this.lifecycle.stopping,
-            stop: (outcome) => this.stop(outcome),
-            resourceLimit: (kind, limit, observed) => this.resourceLimit(kind, limit, observed),
-            resetTimer: () => this.resetResourceTimer(),
-            reference: (entry) => this.stream.reference(entry),
-        }, this.startedAt);
-        this.stream = new ChildStreamObserver(this.spool, {
-            claude: options.claudeCodeInvocation !== undefined,
-            sessionFile: options.sessionFile,
-            consume: (value, textWritten) => this.events.process(value, textWritten),
-            output: options.onOutput,
-            rawLine: options.onRawLine,
-        });
-        child.stdout.on("data", (bytes) => this.receive(bytes));
-        child.stderr.setEncoding("utf8");
-        child.stderr.on("data", (text) => this.receiveStderr(text));
-        child.on("close", (code, signal) => this.finish(code, signal));
-        child.on("error", (error) => this.finish(1, undefined, error));
-    }
-    completed() {
-        return this.completion.promise;
-    }
-    start() {
-        this.listenForCancellation();
-        this.resetResourceTimer();
-        const lifecycle = this.lifecycle;
-        this.options.onStart?.({
-            pid: this.pid,
-            get stopping() {
-                return lifecycle.stopping;
-            },
-            stop: (outcome) => this.stop(outcome),
-        }, this.events.result);
-    }
-    stop(outcome) {
-        if (this.settled) {
-            return;
-        }
-        Object.assign(this.events.result, outcome);
-        this.events.result.durationMs = Date.now() - this.startedAt;
-        if (nonempty(outcome.error)) {
-            this.options.onOutput?.(`${outcome.error}\n`);
-        }
-        this.options.onFailure?.(this.events.result);
-        this.lifecycle.terminate();
-    }
-    resourceLimit(kind, limit, observed) {
-        const result = this.events.result;
-        if (this.settled ||
-            result.resourceLimitExceeded ||
-            result.timedOut === true ||
-            this.lifecycle.stopping) {
-            return;
-        }
-        const message = formatResourceLimitExceeded({
-            agent: this.options.agent,
-            kind,
-            limit,
-            observed,
-        });
-        result.resourceLimitExceeded = {
-            kind,
-            limit,
-            ...(observed !== undefined ? { observed } : {}),
-            message,
-        };
-        this.stop({ error: message });
-    }
-    resetResourceTimer() {
-        clearTimeout(this.resourceTimer);
-        const limit = this.options.maxExecutionTimeMs;
-        if (limit === undefined) {
-            return;
-        }
-        this.resourceTimer = setTimeout(() => {
-            this.events.sync();
-            if (Date.now() - this.events.boundaries.startedAt >= limit) {
-                this.resourceLimit("maxExecutionTimeMs", limit);
-            }
-            else {
-                this.resetResourceTimer();
-            }
-        }, Math.max(0, limit - (Date.now() - this.events.boundaries.startedAt)));
-        this.resourceTimer.unref();
-    }
-    listenForCancellation() {
-        const { signal, interruptSignal } = this.options;
-        if (signal) {
-            this.abortListener = addAbortListener(signal, () => {
-                const reason = signal.reason;
-                const timedOut = reason instanceof Error && reason.name === "TimeoutError";
-                this.stop({
-                    error: timedOut ? reason.message : "Subagent cancelled.",
-                    timedOut: timedOut || undefined,
-                    interrupted: false,
-                });
-            });
-        }
-        if (interruptSignal) {
-            this.interruptListener = addAbortListener(interruptSignal, () => {
-                if (signal?.aborted === true ||
-                    this.events.result.resourceLimitExceeded ||
-                    this.events.result.timedOut === true) {
-                    return;
-                }
-                this.stop({ interrupted: true, error: undefined });
-            });
-        }
-    }
-    receive(bytes) {
-        try {
-            if (this.receiverFailed) {
-                this.stream.saveUnparsed(bytes);
-            }
-            else {
-                this.stream.write(bytes);
-            }
-        }
-        catch (error) {
-            this.receiverFailed = true;
-            this.events.result.terminalFailure = true;
-            this.stop({ error: `Cannot receive child events: ${errorText(error)}` });
-        }
-    }
-    receiveStderr(text) {
-        try {
-            this.spool.writeStderr(text);
-            this.events.result.stderr = (this.events.result.stderr + text).slice(-16384);
-            this.options.onStderr?.(text);
-        }
-        catch (error) {
-            this.events.result.terminalFailure = true;
-            this.stop({ error: `Cannot save child diagnostics: ${errorText(error)}` });
-        }
-    }
-    drainObservations() {
-        try {
-            if (!this.receiverFailed) {
-                this.stream.finish();
-            }
-        }
-        catch (error) {
-            this.receiverFailed = true;
-            this.events.result.error ??= errorText(error);
-            this.events.result.terminalFailure = true;
-        }
-        try {
-            this.events.sync();
-        }
-        catch (error) {
-            this.events.result.error ??= `Cannot read finalization boundary: ${errorText(error)}`;
-            this.events.result.terminalFailure = true;
-        }
-    }
-    finish(code, signal, spawnError) {
-        if (this.settled) {
-            return;
-        }
-        this.drainObservations();
-        this.settled = true;
-        clearTimeout(this.resourceTimer);
-        this.abortListener?.[Symbol.dispose]();
-        this.interruptListener?.[Symbol.dispose]();
-        const result = this.events.result;
-        result.agentProcessExit = this.lifecycle.agentProcessExit;
-        result.durationMs = Date.now() - this.startedAt;
-        Object.assign(result, childExecutionOutcome({
-            result,
-            options: this.options,
-            code,
-            signal,
-            spawnError,
-            stopping: this.lifecycle.stopping,
-            settledCleanup: this.lifecycle.settledCleanup,
-            cleanAssistantStop: this.events.cleanAssistantStop,
-            assistantError: this.events.assistantError,
-        }));
-        result.finalOutput =
-            result.resourceLimitExceeded?.message ??
-                (this.events.lastOutput.length > 0 ? this.events.lastOutput : this.stream.rawOutput.trim());
-        const boundary = this.events.boundaries.finish(result);
-        result.finalization = boundary.finalization;
-        if (boundary.missing) {
-            result.error = "Native self-review boundary did not return a result.";
-            result.exitCode = 1;
-            result.terminalFailure = true;
-        }
-        this.finalizeAccounting();
-        this.completion.resolve(result);
-    }
-    finalizeAccounting() {
-        const result = this.events.result;
-        const native = accountNativeChild({
-            file: nativeSessionFile(this.options),
-            result,
-            baseline: this.events.baseline,
-            acceptedEntries: this.events.acceptedEntries,
-            reference: (entry) => this.stream.reference(entry),
-            observations: () => this.stream.observed(),
-        });
-        result.accounting = native.accounting;
-        result.nativeSessionId = native.nativeSessionId;
-        result.terminalEntryId = native.terminalEntryId;
-        result.terminalLeafId = native.terminalLeafId;
-        result.effectiveConfiguration = native.effectiveConfiguration;
-        if (native.usage) {
-            result.usage = native.usage;
-        }
-        for (const [index, segment] of (result.finalization ?? []).entries()) {
-            const usage = native.segmentUsage?.at(index);
-            if (usage) {
-                segment.usage = usage;
-            }
-        }
-        const retained = this.stream.published(native.publishedIds);
-        for (const item of retained) {
-            if (nonempty(item.nativeEntryId)) {
-                (result.nativeReferences ??= []).push({
-                    messageNumber: item.number,
-                    entryId: item.nativeEntryId,
-                });
-            }
-        }
-        const audit = this.spool.retain(retained, this.receiverFailed);
-        result.auditPath = audit.auditPath;
-        result.auditSaveError = audit.auditSaveError;
-        result.auditRecords = audit.auditRecords?.slice();
-    }
-}
-/** One owned process group and finalized JSON event stream for either native backend. */
-export async function runChildAttempt(options) {
-    const result = initialResult(options.model);
-    if (options.signal?.aborted === true || options.interruptSignal?.aborted === true) {
-        Object.assign(result, resolveExecutionOutcome({
-            result,
-            signal: options.signal,
-            interruptSignal: options.interruptSignal,
-        }));
-        result.finalOutput = result.error ?? "Interrupted. Waiting for explicit next action.";
-        return result;
-    }
-    let baseline;
-    try {
-        baseline = snapshotNativeBaseline(nativeSessionFile(options));
-    }
-    catch (error) {
-        return {
-            ...result,
-            exitCode: 1,
-            terminalFailure: true,
-            error: `Cannot capture native usage baseline: ${errorText(error)}`,
-        };
-    }
-    let spool;
-    try {
-        spool = new ChildObservationSpool(options.auditPath);
-    }
-    catch (error) {
-        return {
-            ...result,
-            exitCode: 1,
-            terminalFailure: true,
-            error: `Cannot prepare child observations: ${errorText(error)}`,
-        };
-    }
-    const runner = new ChildAttemptRunner(options, baseline, spool);
-    runner.start();
-    return runner.completed();
-}

package/dist/runs/shared/child-boundaries.js

@@ -1,173 +0,0 @@
-import * as path from "node:path";
-import { scanJournal } from "../../shared/journal-reader.js";
-import { FINALIZATION_EVENT, } from "./native-finalization-types.js";
-import { parseNativeFinalizationEvent } from "../background/run-schemas.js";
-import { readFinalizationReport } from "./acceptance.js";
-import { addUsage } from "./native-usage.js";
-import { hasErrorCode } from "../../shared/unknown.js";
-import { nonempty } from "./child-presence.js";
-function segmentUsage(messages) {
-    const usage = {
-        input: 0,
-        output: 0,
-        cacheRead: 0,
-        cacheWrite: 0,
-        cost: 0,
-        turns: 0,
-    };
-    let assistantTokens = 0;
-    for (const message of messages) {
-        if (message.role === "assistant") {
-            usage.turns++;
-            assistantTokens += (message.usage?.input ?? 0) + (message.usage?.output ?? 0);
-        }
-        if ((message.role === "assistant" || message.role === "toolResult") && message.usage) {
-            addUsage(usage, message.usage);
-        }
-    }
-    return { usage, assistantTokens };
-}
-/** Native markers reset per-review limits only after all their messages have been observed. */
-export class ChildBoundaries {
-    options;
-    cursor = 0;
-    pending = new Error("pending native boundary");
-    segments = [];
-    priorUsage = {
-        input: 0,
-        output: 0,
-        cacheRead: 0,
-        cacheWrite: 0,
-        cost: 0,
-        turns: 0,
-    };
-    messageOffset = 0;
-    assistantTokens = 0;
-    startedAt;
-    constructor(options, startedAt) {
-        this.options = options;
-        this.startedAt = startedAt;
-    }
-    snapshot() {
-        return this.segments;
-    }
-    sync(messages, nativeMessageCount) {
-        const config = this.options.config;
-        if (!config) {
-            return;
-        }
-        const file = path.join(path.dirname(config.reportRuntime.schemaPath), "boundaries.jsonl");
-        try {
-            scanJournal(file, () => true, ({ value, end }) => {
-                const marker = parseNativeFinalizationEvent(value);
-                if (marker.nonce !== config.nonce) {
-                    throw new Error("Unexpected finalization nonce");
-                }
-                if (marker.messageCount > nativeMessageCount) {
-                    throw this.pending;
-                }
-                this.accept(marker, messages);
-                this.cursor = end;
-            }, { policy: "live", start: this.cursor });
-        }
-        catch (error) {
-            if (error !== this.pending && !hasErrorCode(error, "ENOENT")) {
-                throw error;
-            }
-        }
-        return this.segments;
-    }
-    accept(marker, messages) {
-        const selected = messages
-            .filter((message) => ["assistant", "user", "toolResult"].includes(message.role))
-            .slice(this.messageOffset, marker.messageCount);
-        const { usage, assistantTokens } = segmentUsage(selected);
-        this.segments.push({
-            event: { ...marker, submission: { ...marker.submission } },
-            messages: selected,
-            usage,
-            durationMs: marker.at - this.startedAt,
-        });
-        this.enforceLimits(marker.at, assistantTokens);
-        if (nonempty(marker.nextPrompt)) {
-            this.messageOffset = marker.messageCount;
-            this.assistantTokens += assistantTokens;
-            for (const key of ["input", "output", "cacheRead", "cacheWrite", "cost", "turns"]) {
-                this.priorUsage[key] += usage[key];
-            }
-            this.startedAt = marker.at;
-            this.options.onReset();
-        }
-        this.options.onMarker(marker);
-    }
-    enforceLimits(at, tokens) {
-        if (this.options.maxTokens !== undefined && tokens >= this.options.maxTokens) {
-            this.options.onLimit("maxTokens", this.options.maxTokens, tokens);
-        }
-        if (this.options.maxExecutionTimeMs !== undefined &&
-            at - this.startedAt >= this.options.maxExecutionTimeMs) {
-            this.options.onLimit("maxExecutionTimeMs", this.options.maxExecutionTimeMs);
-        }
-    }
-    finish(result) {
-        const config = this.options.config;
-        if (!config) {
-            return { missing: false };
-        }
-        const previous = this.segments.at(-1);
-        if (nonempty(previous?.event.nextPrompt)) {
-            this.appendInterruptedReview(result);
-        }
-        const final = this.segments.at(-1);
-        if (!final) {
-            return {
-                missing: result.exitCode === 0 && !nonempty(result.error) && result.interrupted !== true,
-            };
-        }
-        if (final.event.turn > 0) {
-            final.event.submission = {
-                ...readFinalizationReport([...result.messages], config.reportRuntime, {
-                    messageOffset: this.messageOffset,
-                }),
-                error: final.event.submission.error,
-            };
-        }
-        final.execution = {
-            exitCode: result.exitCode,
-            error: result.error,
-            interrupted: result.interrupted,
-            timedOut: result.timedOut,
-            resourceLimitExceeded: result.resourceLimitExceeded,
-            terminalFailure: result.terminalFailure,
-        };
-        return { finalization: this.segments, missing: false };
-    }
-    appendInterruptedReview(result) {
-        const previous = this.segments.at(-1);
-        const config = this.options.config;
-        if (!previous || !config) {
-            return;
-        }
-        const usage = {
-            ...result.usage,
-            contributions: result.usage.contributions?.slice(this.priorUsage.contributions?.length ?? 0),
-        };
-        for (const key of ["input", "output", "cacheRead", "cacheWrite", "cost", "turns"]) {
-            usage[key] -= this.priorUsage[key];
-        }
-        this.segments.push({
-            event: {
-                type: FINALIZATION_EVENT,
-                nonce: config.nonce,
-                turn: previous.event.turn + 1,
-                messageCount: result.messages.length,
-                at: Date.now(),
-                submission: { output: "" },
-                resolvedOutput: previous.event.resolvedOutput,
-            },
-            messages: result.messages.slice(this.messageOffset),
-            usage,
-            durationMs: Date.now() - this.startedAt,
-        });
-    }
-}

package/dist/runs/shared/child-context-filter.js

@@ -1,44 +0,0 @@
-const PARENT_ONLY_CUSTOM_MESSAGE_TYPES = new Set([
-    "subagent-orchestration-instructions",
-    "subagent-slash-result",
-    "subagent-notify",
-    "subagent_control_notice",
-    "subagent-control",
-    "subagent-control-notice",
-]);
-const ORCHESTRATION_TOOLS = new Set(["subagent", "delegate", "agent_runs", "load_subagent"]);
-function parentOnlyMessage(message, fanoutChild) {
-    if (message.role === "custom") {
-        return PARENT_ONLY_CUSTOM_MESSAGE_TYPES.has(message.customType);
-    }
-    return !fanoutChild && message.role === "toolResult" && ORCHESTRATION_TOOLS.has(message.toolName);
-}
-function stripParentToolCalls(message) {
-    if (message.role !== "assistant") {
-        return message;
-    }
-    const content = message.content.filter((block) => block.type !== "toolCall" || !ORCHESTRATION_TOOLS.has(block.name));
-    if (content.length === message.content.length) {
-        return message;
-    }
-    return content.length === 0 ? undefined : { ...message, content };
-}
-/** Only the request-local context changes. Native saved history is never rewritten. */
-export function stripParentOnlySubagentMessages(messages, fanoutChild = false) {
-    let changed = false;
-    const filtered = [];
-    for (const message of messages) {
-        if (parentOnlyMessage(message, fanoutChild)) {
-            changed = true;
-            continue;
-        }
-        const stripped = fanoutChild ? message : stripParentToolCalls(message);
-        if (stripped === undefined) {
-            changed = true;
-            continue;
-        }
-        changed ||= stripped !== message;
-        filtered.push(stripped);
-    }
-    return changed ? filtered : undefined;
-}