@fitchmultz/pi-subagents 0.49.0 → 0.50.0

package/dist/runs/shared/parent-usage.js

@@ -1,233 +0,0 @@
-import { isDeepStrictEqual } from "node:util";
-import { SessionEntryCursor } from "../../shared/session-entries.js";
-import { createParentReceiptReader } from "./parent-receipts.js";
-import { isRecord as isObject } from "../../shared/unknown.js";
-import { observedUsage, optionalString, requiredString } from "./child-message-validation.js";
-import { validateNativeUsage } from "./native-usage.js";
-const PREFIX = "subagent:";
-const UNATTRIBUTED = "unattributed";
-function billableChild(child) {
-    if (child.state === "live" || child.state === "unknown") {
-        return false;
-    }
-    return child.result?.detached !== true && child.result?.accounting?.state !== "incomplete";
-}
-export function finalizedChildUsage(children, index) {
-    return children.flatMap((child) => (index === undefined || child.index === index) && billableChild(child)
-        ? (child.result?.usage.contributions ?? [])
-        : []);
-}
-function isJsonValue(value) {
-    if (value === null ||
-        typeof value === "string" ||
-        typeof value === "number" ||
-        typeof value === "boolean") {
-        return true;
-    }
-    if (Array.isArray(value)) {
-        return value.every((item) => isJsonValue(item));
-    }
-    return isObject(value) && Object.values(value).every((item) => isJsonValue(item));
-}
-function serializeDetails(value) {
-    const serialized = JSON.parse(JSON.stringify(value));
-    if (!isJsonValue(serialized)) {
-        throw new Error("Invalid serialized native usage details");
-    }
-    return serialized;
-}
-function readParentContributions(details) {
-    if (!isObject(details) || !isObject(details.parentUsage)) {
-        return;
-    }
-    const values = details.parentUsage.contributions;
-    if (!Array.isArray(values)) {
-        return;
-    }
-    return values.map((value) => {
-        if (!isObject(value)) {
-            throw new Error("Invalid subagent usage contribution");
-        }
-        const usage = observedUsage(value.usage);
-        if (!usage) {
-            throw new Error("Subagent usage contribution is unavailable");
-        }
-        return {
-            id: requiredString(value.id, "contribution ID"),
-            provider: optionalString(value.provider, "provider"),
-            model: optionalString(value.model, "model"),
-            usage,
-        };
-    });
-}
-function sumUsage(contributions) {
-    const total = {
-        input: 0,
-        output: 0,
-        cacheRead: 0,
-        cacheWrite: 0,
-        totalTokens: 0,
-        cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 },
-    };
-    for (const { usage } of contributions) {
-        validateNativeUsage(usage);
-        for (const key of ["input", "output", "cacheRead", "cacheWrite", "totalTokens"]) {
-            total[key] += usage[key];
-        }
-        for (const key of ["input", "output", "cacheRead", "cacheWrite", "total"]) {
-            total.cost[key] += usage.cost[key];
-        }
-        // These are subsets of output/cacheWrite, never additional total tokens.
-        for (const key of ["reasoning", "cacheWrite1h"]) {
-            if (usage[key] !== undefined) {
-                total[key] = (total[key] ?? 0) + usage[key];
-            }
-        }
-    }
-    return total;
-}
-function sameUsage(a, b) {
-    return isDeepStrictEqual({ ...a, reasoning: a.reasoning, cacheWrite1h: a.cacheWrite1h }, { ...b, reasoning: b.reasoning, cacheWrite1h: b.cacheWrite1h });
-}
-function checkContribution(previous, next) {
-    if (previous &&
-        ((previous.provider ?? UNATTRIBUTED) !== (next.provider ?? UNATTRIBUTED) ||
-            (previous.model ?? UNATTRIBUTED) !== (next.model ?? UNATTRIBUTED) ||
-            !sameUsage(previous.usage, next.usage))) {
-        throw new Error(`Conflicting subagent usage contribution: ${next.id}`);
-    }
-}
-function uniqueContributions(contributions) {
-    const unique = new Map();
-    for (const contribution of contributions) {
-        if (contribution.id.trim().length === 0) {
-            throw new Error("Subagent usage requires a stable native contribution ID");
-        }
-        validateNativeUsage(contribution.usage);
-        checkContribution(unique.get(contribution.id), contribution);
-        unique.set(contribution.id, contribution);
-    }
-    return [...unique.values()];
-}
-class ReceiptIndexOwner {
-    cursor = new SessionEntryCursor();
-    received = new Map();
-    toolNames;
-    constructor(toolNames) {
-        this.toolNames = toolNames;
-    }
-    read(manager, saved) {
-        const changes = this.cursor.read(manager);
-        if (changes.reset) {
-            this.received.clear();
-        }
-        for (const metadata of changes.entries) {
-            if (metadata.type === "usage") {
-                this.observeUsage(metadata);
-            }
-            else if (metadata.type === "message") {
-                this.observeTool(metadata, manager, saved);
-            }
-        }
-        return this.received;
-    }
-    observeUsage(metadata) {
-        const id = "contributionId" in metadata
-            ? optionalString(metadata.contributionId, "contributionId")
-            : undefined;
-        if (id?.startsWith(PREFIX) === true) {
-            this.received.set(id.slice(PREFIX.length), {
-                id: id.slice(PREFIX.length),
-                provider: metadata.provider,
-                model: metadata.model,
-                usage: metadata.usage,
-            });
-        }
-    }
-    toolReceipt(metadata, manager, saved) {
-        return (saved.get(metadata.id) ??
-            ("details" in metadata.message && metadata.message.details !== undefined
-                ? metadata
-                : (manager.getEntry(metadata.id) ?? metadata)));
-    }
-    observeTool(metadata, manager, saved) {
-        if (metadata.message.role !== "toolResult" ||
-            !this.toolNames.includes(metadata.message.toolName)) {
-            return;
-        }
-        const entry = this.toolReceipt(metadata, manager, saved);
-        if (entry.type !== "message" || entry.message.role !== "toolResult") {
-            return;
-        }
-        const contributions = readParentContributions(entry.message.details);
-        // Details/custom notifications alone do not prove native accounting ran.
-        if (contributions !== undefined &&
-            entry.message.usage &&
-            sameUsage(entry.message.usage, sumUsage(contributions))) {
-            for (const contribution of contributions) {
-                this.received.set(contribution.id, contribution);
-            }
-        }
-    }
-}
-function unrecorded(contributions, received) {
-    return uniqueContributions(contributions).filter((contribution) => {
-        const previous = received.get(contribution.id);
-        checkContribution(previous, contribution);
-        return !previous;
-    });
-}
-export function registerParentUsage(pi, toolNames) {
-    const toolReceipts = createParentReceiptReader("inspect");
-    const receipts = new ReceiptIndexOwner(toolNames);
-    pi.on("message_end", (event, ctx) => {
-        const message = event.message;
-        if (message.role !== "toolResult" || !toolNames.includes(message.toolName)) {
-            return;
-        }
-        const details = message.details;
-        const contributions = readParentContributions(details);
-        if (!isObject(details) || contributions === undefined) {
-            return;
-        }
-        const pending = unrecorded(contributions, receipts.read(ctx.sessionManager, toolReceipts.read(ctx.sessionManager.getSessionFile())));
-        const { usage: _usage, ...rest } = message;
-        const { parentUsage: _parentUsage, ...restDetails } = details;
-        // Public replacement hook: native emits/persists final tool messages serially,
-        // even for concurrent tools. No in-memory reservation can outlive an aborted result.
-        return {
-            message: {
-                ...rest,
-                details: serializeDetails({
-                    ...restDetails,
-                    ...(pending.length > 0 ? { parentUsage: { contributions: pending } } : {}),
-                }),
-                ...(pending.length > 0 ? { usage: sumUsage(pending) } : {}),
-            },
-        };
-    });
-    function attach(result, contributions, ctx) {
-        const { usage: _usage, ...rest } = result;
-        const { parentUsage: _parentUsage, ...details } = result.details;
-        if (contributions.length === 0) {
-            return { ...rest, details };
-        }
-        // Required identity/conflict rejection precedes any optional host I/O.
-        const saved = toolReceipts.read(ctx.sessionManager.getSessionFile());
-        const pending = unrecorded(contributions, receipts.read(ctx.sessionManager, saved));
-        // Intent only. Top-level usage is added at final message_end, immediately before native persistence.
-        return {
-            ...rest,
-            details: {
-                ...details,
-                ...(pending.length > 0 ? { parentUsage: { contributions: pending } } : {}),
-            },
-        };
-    }
-    return {
-        isRecorded(contributions, ctx, saved) {
-            return unrecorded(contributions, receipts.read(ctx.sessionManager, saved)).length === 0;
-        },
-        attach,
-    };
-}

package/dist/runs/shared/pi-args.js

@@ -1,217 +0,0 @@
-import * as fs from "node:fs";
-import * as os from "node:os";
-import * as path from "node:path";
-import { fileURLToPath } from "node:url";
-import { resolveMcpDirectToolNames } from "./mcp-direct-tool-allowlist.js";
-import { childRouteEnv, SUBAGENT_EAGER_TOOL_ENV, SUBAGENT_INHERITED_EXTENSIONS_JSON_ENV, } from "./child-route-env.js";
-export * from "./child-route-env.js";
-import { isUnknownArray, isRecord as isObject } from "../../shared/unknown.js";
-import { nonempty } from "./child-presence.js";
-import { splitKnownThinkingSuffix } from "../../shared/model-info.js";
-import { piSessionLaunch } from "./pi-session-launch.js";
-import { loadConfig } from "../../extension/config.js";
-// Managed macOS environments can SIGKILL Node when one argv entry reaches ~930 UTF-8 bytes.
-// Measure the full entry (including the `Task: ` prefix), not just the task body.
-const TASK_ARG_LIMIT_BYTES = 900;
-// Resolve sibling extensions in both layouts: TypeScript sources (tests, jiti) and compiled dist output.
-const MODULE_EXTENSION = import.meta.url.endsWith(".ts") ? ".ts" : ".js";
-const PROMPT_RUNTIME_EXTENSION_PATH = path.join(path.dirname(fileURLToPath(import.meta.url)), `subagent-prompt-runtime${MODULE_EXTENSION}`);
-const FANOUT_CHILD_EXTENSION_PATH = path.join(path.dirname(fileURLToPath(import.meta.url)), "..", "..", "extension", `fanout-child${MODULE_EXTENSION}`);
-export function applyThinkingSuffix(model, thinking) {
-    if (!nonempty(model) || !nonempty(thinking)) {
-        return model;
-    }
-    if (nonempty(splitKnownThinkingSuffix(model).thinkingSuffix)) {
-        return model;
-    }
-    return `${model}:${thinking}`;
-}
-export function normalizeChildProjectTrustPolicy(input) {
-    if (input === "approve" || input === "no-approve" || input === "inherit") {
-        return input;
-    }
-    if (isObject(input) && "childRuns" in input) {
-        return normalizeChildProjectTrustPolicy(input.childRuns);
-    }
-    return input === undefined ? "inherit" : "no-approve";
-}
-export function resolveConfiguredChildProjectTrustPolicy(input, argv = process.argv) {
-    const inherited = findInheritedProjectTrustFlag(argv);
-    const configured = isObject(input) ? input.childRuns : input;
-    const explicitInherit = configured === "inherit";
-    if (explicitInherit) {
-        return inherited ?? "inherit";
-    }
-    if (inherited === "no-approve") {
-        return "no-approve";
-    }
-    if (input === undefined || (isObject(input) && !("childRuns" in input))) {
-        return "approve";
-    }
-    const normalized = normalizeChildProjectTrustPolicy(input);
-    return normalized === "inherit" ? "approve" : normalized;
-}
-function findInheritedProjectTrustFlag(argv) {
-    let inherited;
-    for (const arg of argv) {
-        if (arg === "--approve" || arg === "-a") {
-            inherited = "approve";
-        }
-        if (arg === "--no-approve" || arg === "-na") {
-            inherited = "no-approve";
-        }
-    }
-    return inherited;
-}
-export function resolveChildProjectTrustArgs(policy = "inherit", argv = process.argv) {
-    const inherited = findInheritedProjectTrustFlag(argv);
-    if (policy === "approve") {
-        return inherited === "no-approve" ? ["--no-approve"] : ["--approve"];
-    }
-    if (policy === "no-approve") {
-        return ["--no-approve"];
-    }
-    if (inherited === undefined) {
-        return [];
-    }
-    return [`--${inherited}`];
-}
-function inheritedRuntimeExtensionPaths(env = process.env) {
-    const raw = env[SUBAGENT_INHERITED_EXTENSIONS_JSON_ENV]?.trim();
-    if (!nonempty(raw)) {
-        return [];
-    }
-    try {
-        const parsed = JSON.parse(raw);
-        if (!isUnknownArray(parsed)) {
-            return [];
-        }
-        return parsed.filter((entry) => typeof entry === "string" && entry.trim().length > 0);
-    }
-    catch {
-        return [];
-    }
-}
-function isExtensionTool(tool) {
-    return tool.includes("/") || tool.endsWith(".ts") || tool.endsWith(".js");
-}
-function builtinLoadout(input, declared, fanoutAuthorized, compact) {
-    const builtin = [...declared];
-    if (builtin.length === 0) {
-        return builtin;
-    }
-    if (fanoutAuthorized) {
-        const additions = compact
-            ? ["subagent", "delegate", "agent_runs", "load_subagent"]
-            : ["subagent"];
-        builtin.push(...additions.filter((tool) => !builtin.includes(tool)));
-    }
-    if (input.structuredOutput && !builtin.includes("structured_output")) {
-        builtin.push("structured_output");
-    }
-    if (input.mcpDirectTools !== undefined && input.mcpDirectTools.length > 0) {
-        builtin.push(...resolveMcpDirectToolNames(input.mcpDirectTools, input.cwd));
-    }
-    return builtin;
-}
-function buildToolLoadout(input) {
-    const declared = input.tools?.filter((tool) => !isExtensionTool(tool)) ?? [];
-    const fanoutAuthorized = input.allowSubagents === true || declared.includes("subagent");
-    const compact = fanoutAuthorized && loadConfig().compactChildTools !== false;
-    const tools = builtinLoadout(input, declared, fanoutAuthorized, compact);
-    return {
-        args: tools.length > 0 ? ["--tools", tools.join(",")] : [],
-        toolExtensionPaths: input.tools?.filter(isExtensionTool) ?? [],
-        fanoutAuthorized,
-        // Preserve explicit advanced tools, never inherit them into another profile.
-        eager: declared.includes("subagent"),
-    };
-}
-function buildExtensionArgs(input, fanoutAuthorized, toolExtensionPaths) {
-    const args = [];
-    const runtimeExtensions = fanoutAuthorized
-        ? [
-            PROMPT_RUNTIME_EXTENSION_PATH,
-            FANOUT_CHILD_EXTENSION_PATH,
-            ...inheritedRuntimeExtensionPaths(),
-        ]
-        : [PROMPT_RUNTIME_EXTENSION_PATH, ...inheritedRuntimeExtensionPaths()];
-    if (input.extensions !== undefined) {
-        args.push("--no-extensions");
-        for (const extPath of new Set([
-            ...runtimeExtensions,
-            ...toolExtensionPaths,
-            ...input.extensions,
-        ])) {
-            args.push("--extension", extPath);
-        }
-    }
-    else {
-        for (const extPath of new Set([...runtimeExtensions, ...toolExtensionPaths])) {
-            args.push("--extension", extPath);
-        }
-    }
-    return args;
-}
-function buildPromptArgs(input) {
-    const args = [];
-    if (!input.inheritSkills) {
-        args.push("--no-skills");
-    }
-    if (!input.inheritProjectContext) {
-        args.push("--no-context-files");
-    }
-    let tempDir;
-    if (input.systemPrompt !== undefined && input.systemPrompt !== null) {
-        tempDir = fs.mkdtempSync(path.join(os.tmpdir(), "pi-subagent-"));
-        const promptPath = path.join(tempDir, "system.md");
-        fs.writeFileSync(promptPath, input.systemPrompt, { mode: 0o600 });
-        args.push(input.systemPromptMode === "replace" ? "--system-prompt" : "--append-system-prompt", promptPath);
-    }
-    const taskArg = `Task: ${input.task}`;
-    if (Buffer.byteLength(taskArg) > TASK_ARG_LIMIT_BYTES) {
-        if (!nonempty(tempDir)) {
-            tempDir = fs.mkdtempSync(path.join(os.tmpdir(), "pi-subagent-"));
-        }
-        const taskFilePath = path.join(tempDir, "task.md");
-        fs.writeFileSync(taskFilePath, taskArg, { mode: 0o600 });
-        args.push(`@${taskFilePath}`);
-    }
-    else {
-        args.push(taskArg);
-    }
-    return { args, tempDir };
-}
-export function buildPiArgs(input) {
-    const args = [...input.baseArgs, ...resolveChildProjectTrustArgs(input.projectTrust)];
-    const session = piSessionLaunch(input);
-    args.push(...session.args);
-    const modelArg = applyThinkingSuffix(input.model, input.thinking);
-    if (nonempty(modelArg)) {
-        args.push("--model", modelArg);
-    }
-    const tools = buildToolLoadout(input);
-    args.push(...tools.args, ...buildExtensionArgs(input, tools.fanoutAuthorized, tools.toolExtensionPaths));
-    const prompt = buildPromptArgs(input);
-    args.push(...prompt.args);
-    return {
-        args,
-        env: {
-            ...session.env,
-            [SUBAGENT_EAGER_TOOL_ENV]: tools.eager ? "1" : undefined,
-            ...childRouteEnv(input, tools.fanoutAuthorized),
-        },
-        tempDir: prompt.tempDir,
-    };
-}
-export function cleanupTempDir(tempDir) {
-    if (!nonempty(tempDir)) {
-        return;
-    }
-    try {
-        fs.rmSync(tempDir, { recursive: true, force: true });
-    }
-    catch {
-        // Temp cleanup is best effort.
-    }
-}

package/dist/runs/shared/pi-launch-input.js

@@ -1 +0,0 @@
-export {};

package/dist/runs/shared/pi-session-launch.js

@@ -1,86 +0,0 @@
-import * as fs from "node:fs";
-import * as path from "node:path";
-import { prepareChildExecutionCwd } from "./child-execution-cwd.js";
-import { hasErrorCode, isRecord as isObject } from "../../shared/unknown.js";
-import { nonempty } from "./child-presence.js";
-const SESSION_CWD_PRELOAD_URL = new URL(`session-cwd-preload${import.meta.url.endsWith(".ts") ? ".ts" : ".js"}`, import.meta.url).href;
-// Read only the header; joining chunks before decoding preserves split UTF-8.
-function readSessionHeaderLine(file) {
-    let fd;
-    try {
-        fd = fs.openSync(file, "r");
-    }
-    catch (error) {
-        if (hasErrorCode(error, "ENOENT") && !fs.lstatSync(file, { throwIfNoEntry: false })) {
-            return;
-        }
-        throw error;
-    }
-    try {
-        const chunks = [];
-        const buffer = Buffer.alloc(4096);
-        while (true) {
-            const length = fs.readSync(fd, buffer, 0, buffer.length, null);
-            if (length === 0) {
-                break;
-            }
-            const chunk = buffer.subarray(0, length);
-            const newline = chunk.indexOf(10);
-            chunks.push(Buffer.from(newline < 0 ? chunk : chunk.subarray(0, newline)));
-            if (newline >= 0) {
-                break;
-            }
-        }
-        return Buffer.concat(chunks).toString("utf8");
-    }
-    finally {
-        fs.closeSync(fd);
-    }
-}
-function needsCwdOverride(file, cwd) {
-    try {
-        const line = readSessionHeaderLine(file);
-        if (line === undefined) {
-            return false; // A new session inherits the spawn cwd natively.
-        }
-        const header = JSON.parse(line);
-        if (isObject(header) &&
-            header.type === "session" &&
-            typeof header.cwd === "string" &&
-            path.isAbsolute(header.cwd)) {
-            return fs.realpathSync.native(header.cwd) !== fs.realpathSync.native(cwd);
-        }
-    }
-    catch {
-        // Unknown headers or unavailable directories still need the SDK override.
-    }
-    return true;
-}
-/** Prepare persistence before spawn without modifying an existing session header or identity. */
-export function piSessionLaunch(input) {
-    const args = [];
-    const env = {};
-    if (!nonempty(input.sessionFile)) {
-        if (!input.sessionEnabled) {
-            args.push("--no-session");
-        }
-        if (nonempty(input.sessionDir)) {
-            fs.mkdirSync(input.sessionDir, { recursive: true });
-            args.push("--session-dir", input.sessionDir);
-        }
-        return { args, env };
-    }
-    prepareChildExecutionCwd(input.sessionFile, input.cwd);
-    fs.mkdirSync(path.dirname(input.sessionFile), { recursive: true });
-    args.push("--session", input.sessionFile);
-    if (nonempty(input.cwd) && needsCwdOverride(input.sessionFile, input.cwd)) {
-        env.PI_SUBAGENT_SESSION_CWD = JSON.stringify({
-            sessionFile: path.resolve(input.cwd, input.sessionFile),
-            cwd: input.cwd,
-            nodeOptions: process.env.NODE_OPTIONS,
-        });
-        env.NODE_OPTIONS =
-            `${process.env.NODE_OPTIONS ?? ""} --import=${SESSION_CWD_PRELOAD_URL}`.trim();
-    }
-    return { args, env };
-}

package/dist/runs/shared/pi-spawn.js

@@ -1,66 +0,0 @@
-import * as fs from "node:fs";
-import * as path from "node:path";
-import { fileURLToPath } from "node:url";
-export const PI_CODING_AGENT_PACKAGE = "@earendil-works/pi-coding-agent";
-function isPiPackage(file) {
-    if (!fs.existsSync(file)) {
-        return false;
-    }
-    const pkg = JSON.parse(fs.readFileSync(file, "utf-8"));
-    return (typeof pkg === "object" && pkg !== null && "name" in pkg && pkg.name === PI_CODING_AGENT_PACKAGE);
-}
-export function findPiPackageRootFromEntry(entryPoint) {
-    let dir = path.dirname(entryPoint);
-    while (dir !== path.dirname(dir)) {
-        if (isPiPackage(path.join(dir, "package.json"))) {
-            return dir;
-        }
-        dir = path.dirname(dir);
-    }
-    return;
-}
-function findPathPiPackage() {
-    for (const dir of (process.env.PATH ?? "").split(path.delimiter)) {
-        try {
-            const root = findPiPackageRootFromEntry(fs.realpathSync(path.join(dir, "pi")));
-            if (root !== undefined) {
-                return root;
-            }
-        }
-        catch {
-            // PATH entries can disappear or be wrappers rather than Pi.
-        }
-    }
-    return;
-}
-export function resolveInstalledPiPackageRoot() {
-    try {
-        return findPiPackageRootFromEntry(fileURLToPath(import.meta.resolve(PI_CODING_AGENT_PACKAGE)));
-    }
-    catch {
-        return findPathPiPackage();
-    }
-}
-export function resolvePiPackageRoot() {
-    try {
-        const entry = process.argv.at(1);
-        return entry !== undefined ? findPiPackageRootFromEntry(fs.realpathSync(entry)) : undefined;
-    }
-    catch {
-        // process.argv[1] probing is best-effort; callers can fall back to PATH/package resolution.
-        return;
-    }
-}
-export function requirePiPackageRoot() {
-    const configured = process.env.PI_PACKAGE_DIR;
-    const root = configured !== undefined && configured.length > 0
-        ? configured
-        : (resolvePiPackageRoot() ?? resolveInstalledPiPackageRoot());
-    if (root === undefined) {
-        throw new Error("Could not locate Pi runtime APIs; Pi must be installed and available on PATH.");
-    }
-    return root;
-}
-export function getPiSpawnCommand(args) {
-    return { command: "pi", args: [...args] };
-}