@fitchmultz/pi-subagents 0.49.1 → 0.51.0

package/dist/runs/shared/nested-render.js

@@ -1,156 +0,0 @@
-import { formatDuration, formatTokens, shortenPath } from "../../shared/formatters.js";
-import { formatActivityLabel, formatRunAction } from "../../shared/status-format.js";
-export function countNestedRuns(children) {
-    const counts = {
-        total: 0,
-        running: 0,
-        paused: 0,
-        complete: 0,
-        failed: 0,
-        blocked: 0,
-        queued: 0,
-    };
-    for (const child of children ?? []) {
-        counts.total++;
-        counts[child.state]++;
-        const nested = countNestedRuns([
-            ...(child.children ?? []),
-            ...(child.steps?.flatMap((step) => step.children ?? []) ?? []),
-        ]);
-        counts.total += nested.total;
-        counts.running += nested.running;
-        counts.paused += nested.paused;
-        counts.complete += nested.complete;
-        counts.failed += nested.failed;
-        counts.blocked += nested.blocked;
-        counts.queued += nested.queued;
-    }
-    return counts;
-}
-export function formatNestedAggregate(children) {
-    const counts = countNestedRuns(children);
-    if (counts.total === 0) {
-        return;
-    }
-    const parts = [
-        counts.running > 0 ? `${counts.running} running` : "",
-        counts.paused > 0 ? `${counts.paused} paused` : "",
-        counts.failed > 0 ? `${counts.failed} failed` : "",
-        counts.blocked > 0 ? `${counts.blocked} need human action` : "",
-        counts.complete > 0 ? `${counts.complete} complete` : "",
-        counts.queued > 0 ? `${counts.queued} queued` : "",
-    ].filter(Boolean);
-    return `+${counts.total} nested run${counts.total === 1 ? "" : "s"}${parts.length > 0 ? ` (${parts.join(", ")})` : ""}`;
-}
-function nestedRunLabel(run) {
-    if (run.agent !== undefined && run.agent !== "") {
-        return run.agent;
-    }
-    const agents = run.agents ?? [];
-    if (agents.length === 0) {
-        return run.id;
-    }
-    if (agents.length === 1) {
-        return agents[0] ?? run.id;
-    }
-    return `${agents.slice(0, 2).join(", ")}${agents.length > 2 ? ` +${agents.length - 2}` : ""}`;
-}
-function toolActivity(input) {
-    if (input.currentTool === undefined || input.currentTool === "") {
-        return;
-    }
-    if (input.currentToolStartedAt === undefined) {
-        return `tool ${input.currentTool}`;
-    }
-    return `tool ${input.currentTool} ${formatDuration(Math.max(0, Date.now() - input.currentToolStartedAt))}`;
-}
-function formatNestedActivity(input) {
-    const tool = toolActivity(input);
-    const path = input.currentPath;
-    const facts = [
-        tool,
-        path !== undefined && path !== "" ? shortenPath(path) : undefined,
-        input.turnCount !== undefined ? `${input.turnCount} turns` : undefined,
-        input.toolCount !== undefined ? `${input.toolCount} tools` : undefined,
-        input.totalTokens ? `${formatTokens(input.totalTokens.total)} tok` : undefined,
-    ];
-    const activity = formatActivityLabel(input.lastActivityAt, input.activityState);
-    const text = [activity, ...facts].filter(Boolean).join(" | ");
-    return text === "" ? undefined : text;
-}
-function runLine(child, indent) {
-    const activity = child.state === "running" ? formatNestedActivity(child) : undefined;
-    return `${indent}↳ ${nestedRunLabel(child)} [${child.id}] ${child.state}${activity === undefined ? "" : ` | ${activity}`}${(child.error ?? "") !== "" ? ` | error: ${child.error ?? ""}` : ""}`;
-}
-function stepLine(step, position, index) {
-    const activity = step.status === "running" ? formatNestedActivity(step) : undefined;
-    return `${position.indent}  ${index + 1}. ${step.agent} ${step.status}${activity === undefined ? "" : ` | ${activity}`}${(step.error ?? "") !== "" ? ` | error: ${step.error ?? ""}` : ""}`;
-}
-/** Owns one rendering budget; recursion cannot silently bypass depth or line limits. */
-class NestedRunRenderer {
-    lines = [];
-    options;
-    constructor(options) {
-        this.options = options;
-    }
-    atLimit() {
-        return this.lines.length >= this.options.maxLines;
-    }
-    aggregate(items, indent) {
-        const aggregate = formatNestedAggregate(items);
-        if (aggregate !== undefined && !this.atLimit()) {
-            this.lines.push(`${indent}↳ ${aggregate}`);
-        }
-    }
-    append(items, position) {
-        if (items === undefined || items.length === 0 || this.atLimit()) {
-            return;
-        }
-        if (position.depth > this.options.maxDepth) {
-            this.aggregate(items, position.indent);
-            return;
-        }
-        for (const [index, child] of items.entries()) {
-            if (this.atLimit()) {
-                const aggregate = formatNestedAggregate(items.slice(index));
-                if (aggregate !== undefined) {
-                    this.lines[this.lines.length - 1] = `${position.indent}↳ ${aggregate}`;
-                }
-                return;
-            }
-            this.appendRun(child, position);
-        }
-    }
-    appendRun(child, position) {
-        this.lines.push(runLine(child, position.indent));
-        if (this.options.commandHints === true && !this.atLimit()) {
-            this.lines.push(`${position.indent}  Status: ${formatRunAction("status", child.id, {}, this.options.childSafe)}`);
-        }
-        if (position.depth === this.options.maxDepth) {
-            this.aggregate([...(child.steps?.flatMap((step) => step.children ?? []) ?? []), ...(child.children ?? [])], `${position.indent}  `);
-            return;
-        }
-        this.appendSteps(child, position);
-        this.append(child.children, { depth: position.depth + 1, indent: `${position.indent}  ` });
-    }
-    appendSteps(child, position) {
-        for (const [index, step] of (child.steps ?? []).entries()) {
-            if (this.atLimit()) {
-                return;
-            }
-            this.lines.push(stepLine(step, position, index));
-            this.append(step.children, { depth: position.depth + 1, indent: `${position.indent}    ` });
-        }
-    }
-}
-export function formatNestedRunStatusLines(children, options = {}) {
-    const renderer = new NestedRunRenderer({
-        indent: options.indent ?? "  ",
-        maxDepth: options.maxDepth ?? 2,
-        maxLines: options.maxLines ?? 40,
-        commandHints: options.commandHints ?? false,
-        childSafe: options.childSafe,
-    });
-    renderer.append(children, { depth: 0, indent: options.indent ?? "  " });
-    return renderer.lines;
-}

package/dist/runs/shared/nested-route.js

@@ -1,220 +0,0 @@
-import { randomUUID } from "node:crypto";
-import * as fs from "node:fs";
-import * as path from "node:path";
-import { TEMP_ROOT_DIR } from "../../shared/types.js";
-import { ensureTempRoot } from "../../shared/temp-root.js";
-import { parseNestedPathEnv } from "./nested-path.js";
-import { SUBAGENT_PARENT_CAPABILITY_TOKEN_ENV, SUBAGENT_PARENT_CHILD_INDEX_ENV, SUBAGENT_PARENT_CONTROL_INBOX_ENV, SUBAGENT_PARENT_DEPTH_ENV, SUBAGENT_PARENT_EVENT_SINK_ENV, SUBAGENT_PARENT_PATH_ENV, SUBAGENT_PARENT_ROOT_RUN_ID_ENV, SUBAGENT_PARENT_RUN_ID_ENV, } from "./pi-args.js";
-import { getRunMetadataDir, readRunJson } from "./supervisor-questions.js";
-import { assertSafeNestedId as assertSafeId, isSafeNestedId, NESTED_EVENTS_DIR, ROUTE_FILE, MAX_EVENT_BYTES, MAX_DEPTH, } from "./nested-protocol.js";
-import { isRecord, hasErrorCode } from "../../shared/unknown.js";
-import { clampNumber } from "./nested-validation.js";
-function containedPath(base, candidate) {
-    const resolvedBase = path.resolve(base);
-    const resolvedCandidate = path.resolve(candidate);
-    return (resolvedCandidate === resolvedBase || resolvedCandidate.startsWith(`${resolvedBase}${path.sep}`));
-}
-export function commonRouteRoot(route) {
-    return path.dirname(path.resolve(route.eventSink));
-}
-export function validateRouteShape(route) {
-    assertSafeId("rootRunId", route.rootRunId);
-    assertSafeId("capabilityToken", route.capabilityToken);
-    if (!containedPath(NESTED_EVENTS_DIR, route.eventSink)) {
-        throw new Error("Nested event sink is outside the subagent nested event root.");
-    }
-    if (!containedPath(NESTED_EVENTS_DIR, route.controlInbox)) {
-        throw new Error("Nested control inbox is outside the subagent nested event root.");
-    }
-    if (commonRouteRoot(route) !== path.dirname(path.resolve(route.controlInbox))) {
-        throw new Error("Nested event sink and control inbox must share one route root.");
-    }
-}
-export function createNestedRoute(rootRunId) {
-    assertSafeId("rootRunId", rootRunId);
-    ensureTempRoot();
-    const capabilityToken = randomUUID();
-    const routeRoot = path.join(NESTED_EVENTS_DIR, `${rootRunId}-${capabilityToken}`);
-    const eventSink = path.join(routeRoot, "events");
-    const controlInbox = path.join(routeRoot, "controls");
-    fs.mkdirSync(eventSink, { recursive: true, mode: 0o700 });
-    fs.mkdirSync(controlInbox, { recursive: true, mode: 0o700 });
-    fs.writeFileSync(path.join(routeRoot, ROUTE_FILE), `${JSON.stringify({ rootRunId, capabilityToken, createdAt: Date.now() })}\n`, { mode: 0o600 });
-    return { rootRunId, eventSink, controlInbox, capabilityToken };
-}
-function routeAddressFromEnv(env) {
-    const rootRunId = env[SUBAGENT_PARENT_ROOT_RUN_ID_ENV];
-    const eventSink = env[SUBAGENT_PARENT_EVENT_SINK_ENV];
-    const controlInbox = env[SUBAGENT_PARENT_CONTROL_INBOX_ENV];
-    const capabilityToken = env[SUBAGENT_PARENT_CAPABILITY_TOKEN_ENV];
-    if (rootRunId === undefined ||
-        rootRunId === "" ||
-        eventSink === undefined ||
-        eventSink === "" ||
-        controlInbox === undefined ||
-        controlInbox === "" ||
-        capabilityToken === undefined ||
-        capabilityToken === "") {
-        return undefined;
-    }
-    return { rootRunId, eventSink, controlInbox, capabilityToken };
-}
-export function resolveNestedRouteFromEnv(env = process.env) {
-    const route = routeAddressFromEnv(env);
-    if (!route) {
-        return;
-    }
-    validateRouteShape(route);
-    const routeFile = path.join(commonRouteRoot(route), ROUTE_FILE);
-    const metadata = readRouteMetadata(routeFile);
-    if (metadata.rootRunId !== route.rootRunId ||
-        metadata.capabilityToken !== route.capabilityToken) {
-        throw new Error("Nested event route metadata does not match the provided root id and capability token.");
-    }
-    return route;
-}
-export function resolveInheritedNestedRouteFromEnv(env = process.env) {
-    try {
-        return resolveNestedRouteFromEnv(env);
-    }
-    catch (error) {
-        console.error("Ignoring invalid nested subagent event route:", error);
-        return undefined;
-    }
-}
-export function resolveNestedParentAddressFromEnv(env = process.env) {
-    const parentRunId = env[SUBAGENT_PARENT_RUN_ID_ENV];
-    if (!isSafeNestedId(parentRunId)) {
-        return undefined;
-    }
-    const rawIndex = env[SUBAGENT_PARENT_CHILD_INDEX_ENV];
-    const parentStepIndex = rawIndex !== undefined && /^\d+$/.test(rawIndex) ? Number(rawIndex) : undefined;
-    const depth = Math.min(Math.max(1, clampNumber(Number(env[SUBAGENT_PARENT_DEPTH_ENV])) ?? 1), MAX_DEPTH);
-    const parsedPath = parseNestedPathEnv(env[SUBAGENT_PARENT_PATH_ENV]);
-    const nestedPath = parsedPath.length > 0
-        ? parsedPath
-        : [
-            {
-                runId: parentRunId,
-                ...(parentStepIndex !== undefined ? { stepIndex: parentStepIndex } : {}),
-            },
-        ];
-    return {
-        parentRunId,
-        ...(parentStepIndex !== undefined ? { parentStepIndex } : {}),
-        depth,
-        path: nestedPath,
-    };
-}
-export function resolveNestedAsyncDir(rootRunId, run) {
-    if (run.asyncDir === undefined || run.asyncDir === "") {
-        return undefined;
-    }
-    const resolved = path.resolve(run.asyncDir);
-    if (resolved === getRunMetadataDir(run.id)) {
-        const launch = readRunJson(path.join(resolved, "launch.json"));
-        return durableNestedLaunch(launch, rootRunId, run.parentRunId) ? resolved : undefined;
-    }
-    const nestedRoot = path.resolve(TEMP_ROOT_DIR, "nested-subagent-runs", rootRunId, run.id);
-    const relative = path.relative(nestedRoot, resolved);
-    return resolved === nestedRoot || (!relative.startsWith("..") && !path.isAbsolute(relative))
-        ? resolved
-        : undefined;
-}
-function durableNestedLaunch(value, rootRunId, parentRunId) {
-    return (isRecord(value) &&
-        value.runtimeVersion === 2 &&
-        isRecord(value.nestedRoute) &&
-        value.nestedRoute.rootRunId === rootRunId &&
-        isRecord(value.nestedSelf) &&
-        value.nestedSelf.parentRunId === parentRunId);
-}
-function readRouteMetadata(file) {
-    const metadata = JSON.parse(fs.readFileSync(file, "utf-8"));
-    if (!isRecord(metadata) ||
-        typeof metadata.rootRunId !== "string" ||
-        typeof metadata.capabilityToken !== "string") {
-        throw new Error("Invalid nested route metadata.");
-    }
-    return { rootRunId: metadata.rootRunId, capabilityToken: metadata.capabilityToken };
-}
-function readNestedRoute(routeRoot) {
-    const metadata = readRouteMetadata(path.join(routeRoot, ROUTE_FILE));
-    const route = {
-        rootRunId: metadata.rootRunId,
-        eventSink: path.join(routeRoot, "events"),
-        controlInbox: path.join(routeRoot, "controls"),
-        capabilityToken: metadata.capabilityToken,
-    };
-    validateRouteShape(route);
-    return route;
-}
-export function listNestedRoutes(rootRunId) {
-    const prefix = rootRunId ?? "";
-    let entries;
-    try {
-        entries = fs.readdirSync(NESTED_EVENTS_DIR);
-    }
-    catch (error) {
-        if (hasErrorCode(error, "ENOENT")) {
-            return [];
-        }
-        throw error;
-    }
-    const routes = [];
-    for (const entry of entries) {
-        if (prefix !== "" && !entry.startsWith(`${prefix}-`)) {
-            continue;
-        }
-        try {
-            const route = readNestedRoute(path.join(NESTED_EVENTS_DIR, entry));
-            if (prefix === "" || route.rootRunId === prefix) {
-                routes.push(route);
-            }
-        }
-        catch {
-            continue;
-        }
-    }
-    return routes;
-}
-export function readRouteFiles(dir, include) {
-    let entries;
-    try {
-        entries = fs.readdirSync(dir).filter(include).sort();
-    }
-    catch (error) {
-        if (hasErrorCode(error, "ENOENT")) {
-            return [];
-        }
-        throw error;
-    }
-    return entries.flatMap((entry) => {
-        const filePath = path.join(dir, entry);
-        if (!containedPath(dir, filePath)) {
-            return [];
-        }
-        try {
-            const stat = fs.statSync(filePath);
-            return stat.isFile() && stat.size <= MAX_EVENT_BYTES
-                ? [{ entry, filePath, content: fs.readFileSync(filePath, "utf-8") }]
-                : [];
-        }
-        catch {
-            return [];
-        }
-    });
-}
-export function writeRouteRecord(dir, ts, payload) {
-    const content = `${JSON.stringify(payload)}\n`;
-    if (Buffer.byteLength(content, "utf-8") > MAX_EVENT_BYTES) {
-        throw new Error("Nested route record exceeds the maximum size.");
-    }
-    fs.mkdirSync(dir, { recursive: true, mode: 0o700 });
-    const name = `${String(ts).padStart(13, "0")}-${randomUUID()}.json`;
-    const tmp = path.join(dir, `.${name}.tmp`);
-    const finalPath = path.join(dir, name);
-    fs.writeFileSync(tmp, content, { mode: 0o600 });
-    fs.renameSync(tmp, finalPath);
-    return finalPath;
-}

package/dist/runs/shared/nested-validation.js

@@ -1,216 +0,0 @@
-import { sanitizeNestedPath } from "./nested-path.js";
-import { isRecord } from "../../shared/unknown.js";
-import { isSafeNestedId, MAX_DEPTH, MAX_STEPS, MAX_CHILDREN, MAX_EVENT_BYTES, } from "./nested-protocol.js";
-export function clampNumber(value) {
-    return typeof value === "number" && Number.isFinite(value) ? value : undefined;
-}
-export function stringValue(value, max = 512) {
-    return typeof value === "string" && value.length > 0 ? value.slice(0, max) : undefined;
-}
-function textFields(raw, keys, max) {
-    const result = {};
-    for (const key of keys) {
-        const value = stringValue(raw[key], max);
-        if (value !== undefined) {
-            result[key] = value;
-        }
-    }
-    return result;
-}
-function numberFields(raw, keys) {
-    const result = {};
-    for (const key of keys) {
-        const value = clampNumber(raw[key]);
-        if (value !== undefined) {
-            result[key] = value;
-        }
-    }
-    return result;
-}
-function activity(raw) {
-    return {
-        ...textFields(raw, ["currentTool"], 128),
-        ...textFields(raw, ["currentPath"], 2048),
-        ...textFields(raw, ["error"], 1024),
-        ...numberFields(raw, [
-            "lastActivityAt",
-            "currentToolStartedAt",
-            "turnCount",
-            "toolCount",
-            "startedAt",
-            "endedAt",
-        ]),
-        ...(raw.activityState === "needs_attention" ? { activityState: "needs_attention" } : {}),
-    };
-}
-function sanitizeTokenUsage(value) {
-    if (!isRecord(value)) {
-        return;
-    }
-    const input = clampNumber(value.input);
-    const output = clampNumber(value.output);
-    const total = clampNumber(value.total);
-    return input !== undefined && output !== undefined && total !== undefined
-        ? { input, output, total }
-        : undefined;
-}
-const RUN_STATES = [
-    "queued",
-    "running",
-    "complete",
-    "failed",
-    "blocked",
-    "paused",
-];
-function sanitizeState(value) {
-    return RUN_STATES.find((state) => state === value) ?? "running";
-}
-const STEP_STATES = [
-    "pending",
-    "running",
-    "complete",
-    "completed",
-    "failed",
-    "blocked",
-    "paused",
-];
-function nestedChildren(raw, depth) {
-    if (depth >= MAX_DEPTH || !Array.isArray(raw.children)) {
-        return {};
-    }
-    return {
-        children: raw.children
-            .map((child) => sanitizeSummary(child, depth + 1))
-            .filter((child) => child !== undefined)
-            .slice(0, MAX_CHILDREN),
-    };
-}
-function sanitizeStep(input, depth) {
-    if (!isRecord(input)) {
-        return;
-    }
-    const agent = stringValue(input.agent, 128);
-    if (agent === undefined) {
-        return;
-    }
-    return {
-        agent,
-        status: STEP_STATES.find((state) => state === input.status) ?? "pending",
-        ...textFields(input, ["sessionFile"], 2048),
-        ...activity(input),
-        ...nestedChildren(input, depth),
-    };
-}
-function summaryIdentity(raw) {
-    const pid = clampNumber(raw.pid);
-    const ownerState = raw.ownerState;
-    const mode = raw.mode;
-    return {
-        ...textFields(raw, ["parentAgent", "capabilityToken", "agent"], 128),
-        ...textFields(raw, ["asyncDir", "sessionFile", "controlInbox"], 2048),
-        ...textFields(raw, ["sessionId", "intercomTarget", "ownerIntercomTarget", "leafIntercomTarget"], 256),
-        ...(pid !== undefined && pid > 0 && Number.isInteger(pid) ? { pid } : {}),
-        ...(ownerState === "live" || ownerState === "gone" || ownerState === "unknown"
-            ? { ownerState }
-            : {}),
-        ...(mode === "single" || mode === "parallel" || mode === "chain" ? { mode } : {}),
-    };
-}
-function summaryWork(raw, depth) {
-    const totalTokens = sanitizeTokenUsage(raw.totalTokens);
-    const steps = Array.isArray(raw.steps)
-        ? raw.steps
-            .map((step) => sanitizeStep(step, depth + 1))
-            .filter((step) => step !== undefined)
-            .slice(0, MAX_STEPS)
-        : undefined;
-    return {
-        ...(Array.isArray(raw.agents)
-            ? {
-                agents: raw.agents
-                    .map((agent) => stringValue(agent, 128))
-                    .filter((agent) => agent !== undefined)
-                    .slice(0, MAX_STEPS),
-            }
-            : {}),
-        ...numberFields(raw, ["currentStep", "chainStepCount", "lastUpdate"]),
-        ...(totalTokens ? { totalTokens } : {}),
-        ...(steps && steps.length > 0 ? { steps } : {}),
-        ...nestedChildren(raw, depth),
-    };
-}
-export function sanitizeSummary(input, depth = 0) {
-    if (!isRecord(input) || !isSafeNestedId(input.id) || !isSafeNestedId(input.parentRunId)) {
-        return;
-    }
-    return {
-        id: input.id,
-        parentRunId: input.parentRunId,
-        ...numberFields(input, ["parentStepIndex"]),
-        depth: Math.min(Math.max(0, clampNumber(input.depth) ?? 0), MAX_DEPTH),
-        path: sanitizeNestedPath(input.path),
-        state: sanitizeState(input.state),
-        ...(input.indexedControl === true ? { indexedControl: true } : {}),
-        ...summaryIdentity(input),
-        ...activity(input),
-        ...summaryWork(input, depth),
-    };
-}
-export function parseRouteRecord(content, route) {
-    if (Buffer.byteLength(content, "utf-8") > MAX_EVENT_BYTES) {
-        return;
-    }
-    try {
-        const raw = JSON.parse(content);
-        if (isRecord(raw) &&
-            raw.rootRunId === route.rootRunId &&
-            raw.capabilityToken === route.capabilityToken) {
-            return raw;
-        }
-    }
-    catch {
-        // An incomplete or malformed immutable event is not admissible evidence.
-    }
-    return;
-}
-export function parseRecord(content, route) {
-    const raw = parseRouteRecord(content, route);
-    if (!raw || !isSafeNestedId(raw.parentRunId)) {
-        return;
-    }
-    if (raw.type !== "subagent.nested.started" &&
-        raw.type !== "subagent.nested.updated" &&
-        raw.type !== "subagent.nested.completed") {
-        return;
-    }
-    const ts = clampNumber(raw.ts);
-    const child = sanitizeSummary(raw.child);
-    if (ts === undefined || !child || child.id === route.rootRunId) {
-        return;
-    }
-    return {
-        type: raw.type,
-        ts,
-        rootRunId: route.rootRunId,
-        parentRunId: raw.parentRunId,
-        ...numberFields(raw, ["parentStepIndex"]),
-        capabilityToken: route.capabilityToken,
-        child: {
-            ...child,
-            controlInbox: route.controlInbox,
-            capabilityToken: route.capabilityToken,
-            ownerState: child.ownerState ?? "unknown",
-        },
-    };
-}
-export function parseNestedEventRecords(content, route) {
-    if (!content.includes("\n")) {
-        const record = parseRecord(content.trim(), route);
-        return record ? [record] : [];
-    }
-    return content
-        .split("\n")
-        .slice(0, content.endsWith("\n") ? undefined : -1)
-        .map((line) => (line.trim().length > 0 ? parseRecord(line, route) : undefined))
-        .filter((event) => event !== undefined);
-}