@fitchmultz/pi-subagents 0.49.1 → 0.50.0

package/dist/runs/shared/workflow-graph.js

@@ -1,306 +0,0 @@
-import { isDynamicParallelStep, isParallelStep } from "../../shared/settings.js";
-/** Pending fanouts keep their own slot until their actual children are known. */
-export function workflowAgentNodes(graph) {
-    return graph.nodes.flatMap((node) => {
-        if ((node.children?.length ?? 0) > 0) {
-            return node.children ?? [];
-        }
-        if (node.kind === "dynamic-parallel-group" &&
-            node.status !== "completed" &&
-            node.status !== "complete") {
-            return [node];
-        }
-        return node.children ?? [node];
-    });
-}
-export function workflowChildren(children, graph) {
-    if (!graph ||
-        (graph.mode !== "chain" && !children.some((child) => (child.workflowNodeId ?? "") !== ""))) {
-        return children;
-    }
-    const result = [];
-    for (const [index, node] of workflowAgentNodes(graph).entries()) {
-        const declared = children.find((child) => child.workflowNodeId === node.id);
-        result.push({
-            ...declared,
-            index,
-            workflowNodeId: node.id,
-            agent: node.agent ?? declared?.agent ?? "unknown",
-            ...(node.itemKey !== undefined ? { label: node.label } : {}),
-        });
-    }
-    return result;
-}
-/** Admit saved node identity only when it agrees with the actual child slots. */
-export function savedWorkflowNodes(status) {
-    if (!status?.workflowGraph || status.workflowGraph.runId !== status.runId) {
-        return;
-    }
-    const nodes = workflowAgentNodes(status.workflowGraph);
-    if (nodes.length !== status.steps?.length ||
-        new Set(nodes.map((node) => node.id)).size !== nodes.length) {
-        return;
-    }
-    if (nodes.some((node, index) => node.id === "" ||
-        ((node.agent ?? "") !== "" && node.agent !== status.steps?.[index]?.agent))) {
-        return;
-    }
-    return nodes;
-}
-function normalizeStatus(status) {
-    switch (status) {
-        case "complete":
-        case "completed":
-            return "completed";
-        case "running":
-            return "running";
-        case "failed":
-            return "failed";
-        case "paused":
-            return "paused";
-        case "blocked":
-            return "blocked";
-        case "detached":
-            return "detached";
-        case "timed-out":
-            return "timed-out";
-        case "pending":
-            return "pending";
-        case undefined:
-            return undefined;
-        default:
-            return undefined;
-    }
-}
-function resultStatus(result) {
-    if (!result) {
-        return undefined;
-    }
-    if (result.detached === true) {
-        return "detached";
-    }
-    if (result.timedOut === true) {
-        return "timed-out";
-    }
-    if (result.interrupted === true) {
-        return "paused";
-    }
-    if (result.exitCode !== 0) {
-        return "failed";
-    }
-    return result.acceptance?.status === "blocked" ? "blocked" : "completed";
-}
-function summarizeParallelStatuses(statuses) {
-    for (const priority of [
-        "running",
-        "failed",
-        "timed-out",
-        "blocked",
-        "paused",
-        "detached",
-    ]) {
-        if (statuses.includes(priority)) {
-            return priority;
-        }
-    }
-    if (statuses.length > 0 && statuses.every((status) => status === "completed")) {
-        return "completed";
-    }
-    return statuses.includes("completed") ? "running" : "pending";
-}
-function firstLabel(...labels) {
-    return (labels
-        .slice(0, -1)
-        .find((label) => (label?.trim().length ?? 0) > 0)
-        ?.trim() ??
-        labels.at(-1) ??
-        "");
-}
-function agentLabel(label, agent, fallback) {
-    const trimmed = label?.trim() ?? "";
-    if (trimmed.length > 0) {
-        return trimmed;
-    }
-    return agent.length > 0 ? agent : fallback;
-}
-/** Owns graph assembly, phase membership, and flat-index assignment during a single snapshot. */
-class GraphBuilder {
-    nodes = [];
-    phases = [];
-    flatIndex = 0;
-    currentNodeId;
-    input;
-    constructor(input) {
-        this.input = input;
-    }
-    status(index) {
-        return (normalizeStatus(this.input.stepStatuses?.[index]?.status) ??
-            resultStatus(this.input.results?.[index]) ??
-            (this.input.currentFlatIndex === index ? "running" : "pending"));
-    }
-    addPhase(phase, nodeId) {
-        if (phase === undefined || phase.length === 0) {
-            return;
-        }
-        let group = this.phases.find((candidate) => candidate.title === phase);
-        if (!group) {
-            group = { title: phase, nodeIds: [] };
-            this.phases.push(group);
-        }
-        group.nodeIds.push(nodeId);
-    }
-    observations(index, fallbackError) {
-        return {
-            acceptanceStatus: this.input.results?.[index]?.acceptance?.status,
-            error: this.input.stepStatuses?.[index]?.error ??
-                this.input.results?.[index]?.error ??
-                fallbackError,
-        };
-    }
-    trackChild(child) {
-        this.addPhase(child.phase, child.id);
-        if (child.status === "running" || this.input.currentFlatIndex === child.flatIndex) {
-            this.currentNodeId = child.id;
-        }
-    }
-    markCurrentGroup(stepIndex, groupId) {
-        if (this.input.currentStepIndex === stepIndex && this.currentNodeId === undefined) {
-            this.currentNodeId = groupId;
-        }
-    }
-    addParallel(step, stepIndex) {
-        const groupId = `step-${stepIndex}`;
-        const children = step.parallel.map((task, taskIndex) => {
-            const index = this.flatIndex++;
-            const child = {
-                id: `step-${stepIndex}-agent-${taskIndex}`,
-                kind: "agent",
-                agent: task.agent,
-                phase: task.phase,
-                label: agentLabel(task.label, task.agent, `Agent ${taskIndex + 1}`),
-                status: this.status(index),
-                flatIndex: index,
-                stepIndex,
-                outputName: task.as,
-                structured: Boolean(task.outputSchema),
-                ...this.observations(index),
-            };
-            this.trackChild(child);
-            return child;
-        });
-        this.markCurrentGroup(stepIndex, groupId);
-        this.nodes.push({
-            id: groupId,
-            kind: "parallel-group",
-            label: step.parallel.length === 1 ? "Parallel task" : `Parallel group (${step.parallel.length})`,
-            status: summarizeParallelStatuses(children.map((child) => child.status)),
-            stepIndex,
-            children,
-        });
-    }
-    dynamicChild(step, task, stepIndex) {
-        return {
-            id: `step-${stepIndex}-item-${task.itemKey.replace(/[^a-zA-Z0-9_-]/g, "-")}`,
-            kind: "agent",
-            agent: task.agent,
-            phase: step.parallel.phase ?? step.phase,
-            label: firstLabel(task.label, step.parallel.label, `${task.agent} ${task.itemKey}`),
-            status: this.status(task.flatIndex),
-            flatIndex: task.flatIndex,
-            stepIndex,
-            itemKey: task.itemKey,
-            outputName: task.outputName,
-            structured: task.structured,
-            ...this.observations(task.flatIndex, task.error),
-        };
-    }
-    dynamicStatus(children, stepIndex) {
-        const override = this.input.dynamicGroupStatuses?.[stepIndex];
-        const emptyStatus = this.input.currentStepIndex === stepIndex ? "running" : "pending";
-        return (override?.status ??
-            (children.length > 0
-                ? summarizeParallelStatuses(children.map((child) => child.status))
-                : emptyStatus));
-    }
-    addDynamic(step, stepIndex) {
-        const groupId = `step-${stepIndex}`;
-        const materialized = this.input.dynamicChildren?.[stepIndex] ?? [];
-        const override = this.input.dynamicGroupStatuses?.[stepIndex];
-        const children = materialized.map((task) => {
-            const child = this.dynamicChild(step, task, stepIndex);
-            this.trackChild(child);
-            return child;
-        });
-        const status = this.dynamicStatus(children, stepIndex);
-        this.markCurrentGroup(stepIndex, groupId);
-        this.nodes.push({
-            id: groupId,
-            kind: "dynamic-parallel-group",
-            label: firstLabel(step.label, step.parallel.label, `Dynamic fanout (${step.collect.as})`),
-            status,
-            stepIndex,
-            outputName: step.collect.as,
-            structured: Boolean(step.collect.outputSchema),
-            acceptanceStatus: override?.acceptance?.status,
-            error: override?.error,
-            dynamic: {
-                sourceOutput: step.expand.from.output,
-                sourcePath: step.expand.from.path,
-                itemName: step.expand.item ?? "item",
-                maxItems: step.expand.maxItems,
-                collectAs: step.collect.as,
-            },
-            children,
-        });
-        if (materialized.length > 0) {
-            this.flatIndex = Math.max(this.flatIndex, ...materialized.map((child) => child.flatIndex + 1));
-        }
-    }
-    addSequential(step, stepIndex) {
-        const index = this.flatIndex++;
-        const status = this.status(index);
-        const id = `step-${stepIndex}`;
-        this.nodes.push({
-            id,
-            kind: "step",
-            agent: step.agent,
-            phase: step.phase,
-            label: agentLabel(step.label, step.agent, `Step ${stepIndex + 1}`),
-            status,
-            flatIndex: index,
-            stepIndex,
-            outputName: step.as,
-            structured: Boolean(step.outputSchema),
-            ...this.observations(index),
-        });
-        this.addPhase(step.phase, id);
-        if (status === "running" ||
-            this.input.currentFlatIndex === index ||
-            this.input.currentStepIndex === stepIndex) {
-            this.currentNodeId = id;
-        }
-    }
-    build() {
-        for (const [stepIndex, step] of this.input.steps.entries()) {
-            if (isParallelStep(step)) {
-                this.addParallel(step, stepIndex);
-            }
-            else if (isDynamicParallelStep(step)) {
-                this.addDynamic(step, stepIndex);
-            }
-            else {
-                this.addSequential(step, stepIndex);
-            }
-        }
-        return {
-            runId: this.input.runId,
-            mode: this.input.mode ?? "chain",
-            phases: this.phases,
-            nodes: this.nodes,
-            currentNodeId: this.currentNodeId,
-        };
-    }
-}
-export function buildWorkflowGraphSnapshot(input) {
-    return new GraphBuilder(input).build();
-}

package/dist/runs/shared/workflow-policy.js

@@ -1,157 +0,0 @@
-import { errorMessage } from "../../shared/unknown.js";
-import { mapConcurrent } from "../../shared/concurrency.js";
-import { outputEntryFromResult } from "./chain-outputs.js";
-import { collectDynamicResults, validateDynamicCollection, } from "./dynamic-fanout.js";
-import { aggregateParallelOutputs, FAIL_FAST_REASON, } from "./parallel-utils.js";
-export function workflowChildSucceeded(result) {
-    return (result.exitCode === 0 &&
-        result.interrupted !== true &&
-        result.detached !== true &&
-        result.timedOut !== true &&
-        result.acceptance?.status !== "blocked");
-}
-function queuedStopReason(signal, interruptSignal, stopped) {
-    if (signal?.aborted === true) {
-        return "cancelled";
-    }
-    return interruptSignal?.aborted === true ? "interrupted" : stopped;
-}
-function resultStopReason(result, failFast) {
-    if (result.detached === true) {
-        return "detached";
-    }
-    if (result.timedOut === true) {
-        return "timed-out";
-    }
-    if (failFast &&
-        result.interrupted !== true &&
-        !childBlocked(result) &&
-        !workflowChildSucceeded(result)) {
-        return "fail-fast";
-    }
-    return undefined;
-}
-export async function runParallelTasks(input) {
-    const failFast = new AbortController();
-    let stopped;
-    return mapConcurrent(input.tasks, input.concurrency, async (task, index) => {
-        const reason = queuedStopReason(input.signal, input.interruptSignal, stopped);
-        if (reason !== undefined) {
-            return input.stoppedTask(task, index, reason);
-        }
-        const result = await input.runTask(task, index, failFast.signal);
-        // A selected-child stop must not skip independent siblings; whole-group stops use interruptSignal.
-        const nextStop = resultStopReason(result, input.failFast === true);
-        stopped ??= nextStop;
-        if (nextStop === "fail-fast") {
-            failFast.abort(FAIL_FAST_REASON);
-        }
-        return result;
-    });
-}
-function childBlocked(result) {
-    return result.exitCode === 0 && result.acceptance?.status === "blocked";
-}
-function summarizeStep(results) {
-    const timedOutIndex = results.findIndex((result) => result.timedOut === true);
-    const interruptedIndex = results.findIndex((result) => result.interrupted === true);
-    const detachedIndex = results.findIndex((result) => result.detached === true);
-    const failedIndices = results.flatMap((result, index) => !workflowChildSucceeded(result) &&
-        result.timedOut !== true &&
-        result.interrupted !== true &&
-        result.detached !== true &&
-        !childBlocked(result)
-        ? [index]
-        : []);
-    let status = "completed";
-    if (failedIndices.length > 0) {
-        status = "failed";
-    }
-    else if (timedOutIndex >= 0) {
-        status = "timed-out";
-    }
-    else if (results.some(childBlocked)) {
-        status = "blocked";
-    }
-    else if (interruptedIndex >= 0) {
-        status = "paused";
-    }
-    else if (detachedIndex >= 0) {
-        status = "detached";
-    }
-    return { status, failedIndices, timedOutIndex, interruptedIndex, detachedIndex };
-}
-function collectStepOutput(input) {
-    if (!input.dynamic) {
-        return {
-            outputs: {},
-            previousOutput: input.parallel === true
-                ? aggregateParallelOutputs(input.results)
-                : (input.results[0]?.output ?? input.previousOutput),
-        };
-    }
-    const { step, items } = input.dynamic;
-    if (items.length !== input.results.length) {
-        throw new Error("Dynamic fanout did not complete every child.");
-    }
-    const collection = collectDynamicResults(step, items, input.results);
-    validateDynamicCollection(step.collect.outputSchema, collection);
-    const outputs = {
-        [step.collect.as]: {
-            text: JSON.stringify(collection),
-            structured: collection,
-            agent: step.parallel.agent,
-            stepIndex: input.stepIndex,
-        },
-    };
-    const previousOutput = items.length === 0
-        ? "Dynamic fanout produced 0 results."
-        : aggregateParallelOutputs(input.results, (index, agent) => `=== Dynamic Item ${index + 1} (${agent}, key ${items[index]?.key ?? index}) ===`);
-    return { outputs, previousOutput, collection };
-}
-function successfulNamedOutputs(input) {
-    const outputs = {};
-    for (const [index, result] of input.results.entries()) {
-        const name = input.outputNames?.[index];
-        if (workflowChildSucceeded(result) && name !== undefined && name.length > 0) {
-            Object.defineProperty(outputs, name, {
-                value: outputEntryFromResult(result, input.stepIndex),
-                enumerable: true,
-                writable: true,
-                configurable: true,
-            });
-        }
-    }
-    return outputs;
-}
-export function completeWorkflowStep(input) {
-    const summary = summarizeStep(input.results);
-    let outputs = successfulNamedOutputs(input);
-    let status = summary.status;
-    let previousOutput = input.previousOutput;
-    let collection;
-    let error;
-    if (status === "completed") {
-        try {
-            const collected = collectStepOutput(input);
-            outputs = { ...outputs, ...collected.outputs };
-            previousOutput = collected.previousOutput;
-            collection = collected.collection;
-        }
-        catch (cause) {
-            error = errorMessage(cause);
-            status = "failed";
-        }
-    }
-    const advance = status === "completed";
-    return {
-        ...summary,
-        status,
-        advance,
-        complete: advance && input.stepIndex + 1 === input.stepCount,
-        outputs,
-        previousOutput,
-        collection,
-        error,
-    };
-}

package/dist/runs/shared/worktree-contract.js

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

package/dist/runs/shared/worktree-hook.js

@@ -1,138 +0,0 @@
-import { errorMessage, isRecord, isUnknownArray } from "../../shared/unknown.js";
-import * as fs from "node:fs";
-import * as os from "node:os";
-import * as path from "node:path";
-import { runSetupCommand } from "./worktree-process.js";
-export const DEFAULT_WORKTREE_SETUP_HOOK_TIMEOUT_MS = 30_000;
-function parseHookTimeout(timeoutMs) {
-    if (timeoutMs === undefined) {
-        return DEFAULT_WORKTREE_SETUP_HOOK_TIMEOUT_MS;
-    }
-    if (!Number.isInteger(timeoutMs) || timeoutMs <= 0) {
-        throw new Error("worktree setup hook timeout must be an integer greater than 0");
-    }
-    return timeoutMs;
-}
-export function resolveWorktreeSetupHook(repoRoot, config) {
-    if (!config) {
-        return undefined;
-    }
-    const hookPath = config.hookPath.trim();
-    if (hookPath.length === 0) {
-        throw new Error("worktree setup hook path cannot be empty");
-    }
-    const expandedHookPath = hookPath.startsWith("~/")
-        ? path.join(os.homedir(), hookPath.slice(2))
-        : hookPath;
-    let resolvedPath;
-    if (path.isAbsolute(expandedHookPath)) {
-        resolvedPath = expandedHookPath;
-    }
-    else if (expandedHookPath.includes("/") || expandedHookPath.includes("\\")) {
-        resolvedPath = path.resolve(repoRoot, expandedHookPath);
-    }
-    else {
-        throw new Error("worktree setup hook must be an absolute path or a repo-relative path");
-    }
-    if (!fs.existsSync(resolvedPath)) {
-        throw new Error(`worktree setup hook not found: ${resolvedPath}`);
-    }
-    if (fs.statSync(resolvedPath).isDirectory()) {
-        throw new Error(`worktree setup hook must be a file, got directory: ${resolvedPath}`);
-    }
-    return { hookPath: resolvedPath, timeoutMs: parseHookTimeout(config.timeoutMs) };
-}
-function normalizeSyntheticPath(worktreePath, rawPath) {
-    const trimmed = rawPath.trim();
-    if (trimmed.length === 0) {
-        throw new Error("synthetic path cannot be empty");
-    }
-    if (path.isAbsolute(trimmed)) {
-        throw new Error(`synthetic path must be relative: ${rawPath}`);
-    }
-    const relative = path.relative(worktreePath, path.resolve(worktreePath, trimmed));
-    if (relative.length === 0 || relative === ".") {
-        throw new Error(`synthetic path cannot target the worktree root: ${rawPath}`);
-    }
-    if (relative === ".." || relative.startsWith(`..${path.sep}`) || path.isAbsolute(relative)) {
-        throw new Error(`synthetic path escapes the worktree root: ${rawPath}`);
-    }
-    return path.normalize(relative);
-}
-function requirePathStrings(paths) {
-    if (!isUnknownArray(paths)) {
-        throw new Error("worktree setup hook output field 'syntheticPaths' must be an array of relative paths");
-    }
-    const result = [];
-    for (const candidate of paths) {
-        if (typeof candidate !== "string") {
-            throw new Error("worktree setup hook output field 'syntheticPaths' must contain only strings");
-        }
-        result.push(candidate);
-    }
-    return result;
-}
-function parseSyntheticPaths(rawStdout) {
-    const trimmed = rawStdout.trim();
-    if (trimmed.length === 0) {
-        throw new Error("worktree setup hook returned empty stdout; expected JSON object");
-    }
-    let parsed;
-    try {
-        parsed = JSON.parse(trimmed);
-    }
-    catch (error) {
-        const message = errorMessage(error);
-        throw new Error(`worktree setup hook returned invalid JSON: ${message}`, { cause: error });
-    }
-    if (!isRecord(parsed)) {
-        throw new Error("worktree setup hook stdout must be a JSON object");
-    }
-    if (!("syntheticPaths" in parsed) || parsed.syntheticPaths === undefined) {
-        return [];
-    }
-    return requirePathStrings(parsed.syntheticPaths);
-}
-/** Validates hook-declared scratch paths against Git before granting cleanup authority. */
-async function validateSyntheticPaths(input, paths, signal) {
-    const uniquePaths = new Set();
-    for (const candidate of paths) {
-        const normalizedPath = normalizeSyntheticPath(input.worktreePath, candidate);
-        // Keep Git queries ordered and stop before granting authority to another path on cancellation.
-        // oxlint-disable-next-line no-await-in-loop
-        const result = await runSetupCommand({
-            command: "git",
-            args: ["-C", input.worktreePath, "ls-files", "--", normalizedPath],
-            cwd: input.worktreePath,
-            signal,
-        });
-        if (result.status === 0 && result.stdout.trim().length > 0) {
-            throw new Error(`worktree setup hook cannot mark tracked paths as synthetic: ${normalizedPath}`);
-        }
-        uniquePaths.add(normalizedPath);
-    }
-    return [...uniquePaths];
-}
-export async function runWorktreeSetupHook(hook, input, signal) {
-    let result;
-    try {
-        result = await runSetupCommand({
-            command: hook.hookPath,
-            args: [],
-            cwd: input.worktreePath,
-            signal,
-            input: JSON.stringify(input),
-            timeoutMs: hook.timeoutMs,
-        });
-    }
-    catch (error) {
-        signal?.throwIfAborted();
-        const message = errorMessage(error);
-        throw new Error(`worktree setup hook failed: ${message}`, { cause: error });
-    }
-    if (result.status !== 0) {
-        const details = [result.stderr.trim(), result.stdout.trim()].find((text) => text.length > 0) ?? "no output";
-        throw new Error(`worktree setup hook failed with exit code ${String(result.status)}: ${details}`);
-    }
-    return validateSyntheticPaths(input, parseSyntheticPaths(result.stdout), signal);
-}

package/dist/runs/shared/worktree-location.js

@@ -1,47 +0,0 @@
-import * as fs from "node:fs";
-import * as path from "node:path";
-import { TEMP_ROOT_DIR } from "../../shared/types.js";
-import { runGit, runGitChecked } from "./worktree-process.js";
-function normalizeComparableCwd(cwd) {
-    const resolved = path.resolve(cwd);
-    try {
-        return fs.realpathSync(resolved);
-    }
-    catch {
-        return resolved;
-    } // Missing paths are still compared as absolute paths.
-}
-export function findWorktreeTaskCwdConflict(tasks, sharedCwd) {
-    const normalizedSharedCwd = normalizeComparableCwd(sharedCwd);
-    for (const [index, task] of tasks.entries()) {
-        if (task.cwd === undefined || task.cwd.length === 0) {
-            continue;
-        }
-        const taskCwd = path.isAbsolute(task.cwd) ? task.cwd : path.resolve(sharedCwd, task.cwd);
-        if (normalizeComparableCwd(taskCwd) === normalizedSharedCwd) {
-            continue;
-        }
-        return { index, agent: task.agent, cwd: task.cwd };
-    }
-    return undefined;
-}
-export function formatWorktreeTaskCwdConflict(conflict, sharedCwd) {
-    return `worktree isolation uses the shared cwd (${sharedCwd}); task ${conflict.index + 1} (${conflict.agent}) sets cwd to ${conflict.cwd}. Remove task-level cwd overrides or disable worktree.`;
-}
-export function buildWorktreeBranch(runId, index) {
-    return `pi-parallel-${runId}-${index}`;
-}
-export function buildWorktreePath(runId, index) {
-    return path.join(TEMP_ROOT_DIR, "worktrees", `pi-worktree-${runId}-${index}`);
-}
-export function resolveExpectedWorktreeAgentCwd(cwd, runId, index) {
-    const repoCheck = runGit(cwd, ["rev-parse", "--is-inside-work-tree"]);
-    if (repoCheck.status !== 0 || repoCheck.stdout.trim() !== "true") {
-        throw new Error("worktree isolation requires a git repository");
-    }
-    const rawPrefix = runGitChecked(cwd, ["rev-parse", "--show-prefix"]).trim();
-    const normalized = rawPrefix.length > 0 ? path.normalize(rawPrefix.replace(/[\\/]+$/, "")) : "";
-    const cwdRelative = normalized === "." ? "" : normalized;
-    const worktreePath = buildWorktreePath(runId, index);
-    return cwdRelative.length > 0 ? path.join(worktreePath, cwdRelative) : worktreePath;
-}

package/dist/runs/shared/worktree-preservation.js

@@ -1,8 +0,0 @@
-/** Resource owner mutation: failed patch capture must prohibit destructive cleanup. */
-export function markWorktreesForPreservation(setup, reason) {
-    setup.preserveOnCleanup = true;
-    setup.preservationReason =
-        (setup.preservationReason ?? "").length > 0
-            ? `${setup.preservationReason ?? ""}; ${reason}`
-            : reason;
-}