@fitchmultz/pi-subagents 0.49.1 → 0.50.0

package/dist/runs/background/runner-reporting.js

@@ -1,153 +0,0 @@
-var __rewriteRelativeImportExtension = (this && this.__rewriteRelativeImportExtension) || function (path, preserveJsx) {
-    if (typeof path === "string" && /^\.\.?\//.test(path)) {
-        return path.replace(/\.(tsx)$|((?:\.d)?)((?:\.[^./]+?)?)\.([cm]?)ts$/i, function (m, tsx, d, ext, cm) {
-            return tsx ? preserveJsx ? ".jsx" : ".js" : d && (!ext || !cm) ? m : (d + ext + "." + cm.toLowerCase() + "js");
-        });
-    }
-    return path;
-};
-import { spawnSync } from "node:child_process";
-import * as fs from "node:fs";
-import * as path from "node:path";
-import { pathToFileURL } from "node:url";
-import { inspect } from "node:util";
-import { findLatestSessionFile } from "../../shared/utils.js";
-import { PI_CODING_AGENT_PACKAGE, resolveInstalledPiPackageRoot } from "../shared/pi-spawn.js";
-export function runnerErrorMessage(error) {
-    if (error instanceof Error) {
-        return error.message;
-    }
-    return typeof error === "string" ? error : inspect(error);
-}
-function resolvePiPackageRootFallback() {
-    const root = resolveInstalledPiPackageRoot();
-    if (root !== undefined && root.length > 0) {
-        return root;
-    }
-    throw new Error(`Could not resolve ${PI_CODING_AGENT_PACKAGE} package root`);
-}
-export async function exportSessionHtml(sessionFile, outputDir, piPackageRoot) {
-    const pkgRoot = piPackageRoot ?? resolvePiPackageRootFallback();
-    const exportModulePath = path.join(pkgRoot, "dist", "core", "export-html", "index.js");
-    const moduleUrl = pathToFileURL(exportModulePath).href;
-    const mod = await import(__rewriteRelativeImportExtension(moduleUrl));
-    if (typeof mod !== "object" ||
-        mod === null ||
-        !("exportFromFile" in mod) ||
-        typeof mod.exportFromFile !== "function") {
-        throw new Error("exportFromFile not available");
-    }
-    const outputPath = path.join(outputDir, `${path.basename(sessionFile, ".jsonl")}.html`);
-    const exported = await Reflect.apply(mod.exportFromFile, mod, [
-        sessionFile,
-        { outputPath },
-    ]);
-    if (typeof exported !== "string") {
-        throw new Error("exportFromFile returned an invalid output path");
-    }
-    return exported;
-}
-export function createShareLink(htmlPath) {
-    try {
-        const auth = spawnSync("gh", ["auth", "status"], { encoding: "utf-8" });
-        if (auth.status !== 0) {
-            return { error: "GitHub CLI is not logged in. Run 'gh auth login' first." };
-        }
-    }
-    catch {
-        return { error: "GitHub CLI (gh) is not installed." };
-    }
-    try {
-        const result = spawnSync("gh", ["gist", "create", htmlPath], { encoding: "utf-8" });
-        if (result.status !== 0) {
-            const stderr = result.stderr.trim();
-            const err = stderr.length > 0 ? stderr : "Failed to create gist.";
-            return { error: err };
-        }
-        const gistUrl = result.stdout.trim();
-        const gistId = gistUrl.split("/").pop();
-        if (gistId === undefined || gistId.length === 0) {
-            return { error: "Failed to parse gist ID." };
-        }
-        const shareUrl = `https://shittycodingagent.ai/session/?${gistId}`;
-        return { shareUrl, gistUrl };
-    }
-    catch (err) {
-        return { error: runnerErrorMessage(err) };
-    }
-}
-function formatDuration(ms) {
-    if (ms < 1000) {
-        return `${ms}ms`;
-    }
-    if (ms < 60000) {
-        return `${(ms / 1000).toFixed(1)}s`;
-    }
-    const minutes = Math.floor(ms / 60000);
-    const seconds = Math.floor((ms % 60000) / 1000);
-    return `${minutes}m${seconds}s`;
-}
-export function writeRunLog(logPath, input) {
-    const lines = [];
-    lines.push(`# Subagent run ${input.id}`);
-    lines.push("");
-    lines.push(`- **Mode:** ${input.mode}`);
-    lines.push(`- **Launch cwd:** ${input.cwd}`);
-    lines.push(`- **Started:** ${new Date(input.startedAt).toISOString()}`);
-    lines.push(`- **Ended:** ${new Date(input.endedAt).toISOString()}`);
-    lines.push(`- **Duration:** ${formatDuration(input.endedAt - input.startedAt)}`);
-    const references = [
-        { label: "Session", value: input.sessionFile },
-        { label: "Share", value: input.shareUrl },
-        { label: "Share error", value: input.shareError },
-        { label: "Artifacts", value: input.artifactsDir },
-    ];
-    for (const reference of references) {
-        if (reference.value !== undefined && reference.value.length > 0) {
-            lines.push(`- **${reference.label}:** ${reference.value}`);
-        }
-    }
-    lines.push("");
-    lines.push("## Steps");
-    lines.push("| Step | Agent | Status | Duration |");
-    lines.push("| --- | --- | --- | --- |");
-    input.steps.forEach((step, i) => {
-        const duration = step.durationMs !== undefined ? formatDuration(step.durationMs) : "-";
-        lines.push(`| ${i + 1} | ${step.agent} | ${step.status} | ${duration} |`);
-    });
-    lines.push("");
-    lines.push("## Summary");
-    if (input.truncated) {
-        lines.push("_Output truncated_");
-        lines.push("");
-    }
-    const summary = input.summary.trim();
-    lines.push(summary.length > 0 ? summary : "(no output)");
-    lines.push("");
-    fs.writeFileSync(logPath, lines.join("\n"), "utf-8");
-}
-export async function shareRunnerSession(config, latestSessionFile) {
-    if (config.share !== true) {
-        return { sessionFile: latestSessionFile };
-    }
-    const discovered = config.sessionDir === undefined || config.sessionDir.length === 0
-        ? undefined
-        : findLatestSessionFile(config.sessionDir);
-    const sessionFile = discovered ?? latestSessionFile;
-    if (sessionFile === undefined || sessionFile.length === 0) {
-        return { sessionFile: latestSessionFile, shareError: "Session file not found." };
-    }
-    try {
-        const exportDir = config.sessionDir ?? path.dirname(sessionFile);
-        fs.mkdirSync(exportDir, { recursive: true });
-        const htmlPath = await exportSessionHtml(sessionFile, exportDir, config.piPackageRoot);
-        const share = createShareLink(htmlPath);
-        if ("error" in share) {
-            return { sessionFile, shareError: share.error };
-        }
-        return { sessionFile, ...share };
-    }
-    catch (error) {
-        return { sessionFile, shareError: runnerErrorMessage(error) };
-    }
-}

package/dist/runs/background/runner-status.js

@@ -1,148 +0,0 @@
-import * as path from "node:path";
-import { resolveEffectiveThinking } from "../../shared/model-info.js";
-export function pendingRunnerStep(task) {
-    return {
-        agent: task.agent,
-        phase: task.phase,
-        label: task.label,
-        outputName: task.outputName,
-        structured: task.structured,
-        status: "pending",
-        ...(task.sessionFile !== undefined && task.sessionFile.length > 0
-            ? { sessionFile: task.sessionFile }
-            : {}),
-        skills: task.skills?.slice(),
-        model: task.model,
-        thinking: task.thinking,
-        attemptedModels: pendingModelCandidates(task),
-        recentTools: [],
-        recentOutput: [],
-    };
-}
-function pendingModelCandidates(task) {
-    const candidates = task.modelCandidates;
-    if (candidates !== undefined && candidates.length > 0) {
-        return [...candidates];
-    }
-    if (task.model !== undefined && task.model.length > 0) {
-        return [task.model];
-    }
-    return;
-}
-export function tokenUsageFromAttempts(attempts) {
-    if (!attempts || attempts.length === 0) {
-        return null;
-    }
-    let input = 0;
-    let output = 0;
-    for (const attempt of attempts) {
-        input += attempt.usage?.input ?? 0;
-        output += attempt.usage?.output ?? 0;
-    }
-    const total = input + output;
-    return total > 0 ? { input, output, total } : null;
-}
-export function appendRecentStepOutput(step, lines) {
-    const nonEmpty = lines.filter((line) => line.trim().length > 0);
-    if (nonEmpty.length === 0) {
-        return;
-    }
-    step.recentOutput ??= [];
-    step.recentOutput.push(...nonEmpty);
-    if (step.recentOutput.length > 50) {
-        step.recentOutput.splice(0, step.recentOutput.length - 50);
-    }
-}
-export function clearStepCurrentActivity(step) {
-    step.currentTool = undefined;
-    step.currentToolArgs = undefined;
-    step.currentToolStartedAt = undefined;
-    step.currentPath = undefined;
-}
-export function resetStepLiveDetail(step) {
-    clearStepCurrentActivity(step);
-    step.recentTools = [];
-    step.recentOutput = [];
-}
-export function markStepPaused(step, now) {
-    step.status = "paused";
-    step.activityState = undefined;
-    clearStepCurrentActivity(step);
-    step.startedAt ??= now;
-    step.endedAt = now;
-    step.durationMs = now - step.startedAt;
-    step.lastActivityAt = now;
-    step.exitCode = 0;
-}
-export function runnerResultStatus(result) {
-    if (result.interrupted === true) {
-        return "paused";
-    }
-    if (result.exitCode !== 0) {
-        return "failed";
-    }
-    return result.acceptance?.status === "blocked" ? "blocked" : "complete";
-}
-export function runnerResultEvent(result) {
-    const status = runnerResultStatus(result);
-    return status === "complete" ? "subagent.step.completed" : `subagent.step.${status}`;
-}
-/** Mutates only the live step owned by this status boundary; callers publish after transition. */
-export function startRunnerStep(statusPayload, task, input) {
-    const startedAt = Date.now();
-    const step = statusPayload.steps[input.index];
-    statusPayload.currentStep = input.index;
-    step.status = "running";
-    step.activityState = undefined;
-    resetStepLiveDetail(step);
-    step.startedAt = startedAt;
-    if (input.sequential === true) {
-        statusPayload.activityState = undefined;
-        step.skills = task.skills?.slice();
-    }
-    else {
-        step.error = undefined;
-    }
-    if (input.resetTiming === true) {
-        step.endedAt = undefined;
-        step.durationMs = undefined;
-    }
-    step.lastActivityAt = startedAt;
-    statusPayload.outputFile = path.join(input.asyncDir, `output-${input.index}.log`);
-    statusPayload.lastActivityAt = startedAt;
-    statusPayload.lastUpdate = startedAt;
-    return startedAt;
-}
-export function finishRunnerStep(statusPayload, result, input) {
-    const endedAt = Date.now();
-    const step = statusPayload.steps[input.index];
-    Object.assign(step, {
-        status: runnerResultStatus(result),
-        endedAt,
-        durationMs: endedAt - input.startedAt,
-        exitCode: result.exitCode,
-        agentProcessExit: result.agentProcessExit,
-        model: result.model,
-        thinking: resolveEffectiveThinking(result.model, step.thinking),
-        attemptedModels: result.attemptedModels,
-        modelAttempts: result.modelAttempts,
-        error: result.error,
-        structuredOutput: result.structuredOutput,
-        structuredOutputPath: result.structuredOutputPath,
-        structuredOutputSchemaPath: result.structuredOutputSchemaPath,
-        acceptance: result.acceptance,
-        resourceLimitExceeded: result.resourceLimitExceeded,
-    });
-    clearStepCurrentActivity(step);
-    const tokens = tokenUsageFromAttempts(result.modelAttempts);
-    if (tokens !== null || input.sequential !== true) {
-        step.tokens = tokens ?? undefined;
-        statusPayload.totalTokens = statusPayload.steps.reduce((total, candidate) => ({
-            input: total.input + (candidate.tokens?.input ?? 0),
-            output: total.output + (candidate.tokens?.output ?? 0),
-            total: total.total + (candidate.tokens?.total ?? 0),
-        }), { input: 0, output: 0, total: 0 });
-    }
-    statusPayload.lastUpdate = endedAt;
-    return endedAt;
-}

package/dist/runs/background/runner-step-output.js

@@ -1,90 +0,0 @@
-import * as fs from "node:fs";
-import * as path from "node:path";
-import { cleanupSingleOutputFile, finalizeSingleOutput, formatConsumedOutputReference, formatSavedOutputReference, } from "../shared/single-output.js";
-import { formatUnconfirmedFinalizationOutput, } from "../shared/acceptance.js";
-function decorateOutput(input) {
-    let output = input.output;
-    const { acceptance, resolvedOutput, outcome } = input;
-    if (acceptance?.unconfirmedOutput !== undefined) {
-        const saved = resolvedOutput.savedPath;
-        const auditOutput = saved !== undefined && saved.length > 0 && !resolvedOutput.writtenSnapshot
-            ? output
-            : acceptance.unconfirmedOutput;
-        output = formatUnconfirmedFinalizationOutput(auditOutput);
-    }
-    if (outcome.timedOut === true) {
-        const reason = outcome.error ?? "Timed out.";
-        const partial = output.trim();
-        output =
-            partial.length > 0 && partial !== reason
-                ? `${reason}\n\nPartial output before timeout:\n${partial}`
-                : reason;
-    }
-    return output;
-}
-function relocateOutput(ctx, savedPath, cleanup) {
-    const worktree = ctx.worktreePath;
-    if (worktree === undefined ||
-        worktree.length === 0 ||
-        savedPath === undefined ||
-        savedPath.length === 0 ||
-        (cleanup !== undefined && cleanup.action !== "skipped")) {
-        return savedPath;
-    }
-    const relative = path.relative(worktree, savedPath);
-    if (relative === ".." || relative.startsWith(`..${path.sep}`) || path.isAbsolute(relative)) {
-        return savedPath;
-    }
-    const destination = path.join(path.dirname(ctx.outputFile), "outputs", String(ctx.flatIndex), path.basename(savedPath));
-    fs.mkdirSync(path.dirname(destination), { recursive: true });
-    fs.copyFileSync(savedPath, destination);
-    return destination;
-}
-function outputReference(savedPath, output, cleanup) {
-    if (savedPath === undefined || savedPath.length === 0) {
-        return;
-    }
-    return cleanup
-        ? formatConsumedOutputReference(savedPath, output, cleanup)
-        : formatSavedOutputReference(savedPath, output);
-}
-/** Consumes eligible default output or preserves it outside a worktree before that worktree is removed. */
-export function publishStepOutput(step, ctx, state) {
-    const output = decorateOutput(state);
-    const exitCode = state.outcome.exitCode ?? 1;
-    const originalPath = state.resolvedOutput.savedPath;
-    const shouldConsume = exitCode === 0 &&
-        state.outcome.interrupted !== true &&
-        originalPath !== undefined &&
-        originalPath.length > 0 &&
-        step.outputMode !== "file-only" &&
-        step.outputPathFromAgentDefault === true;
-    const cleanup = shouldConsume ? cleanupSingleOutputFile(originalPath, output) : undefined;
-    const savedPath = relocateOutput(ctx, originalPath, cleanup);
-    const reference = outputReference(savedPath, state.resolvedOutput.fullOutput, cleanup);
-    const displayOutput = finalizeSingleOutput({
-        fullOutput: state.attemptNotes.length > 0
-            ? `${state.attemptNotes.join("\n")}\n\n${output}`.trim()
-            : output,
-        outputPath: step.outputPath,
-        outputMode: step.outputMode,
-        exitCode,
-        savedPath,
-        outputReference: reference,
-        saveError: state.resolvedOutput.saveError,
-        cleanup,
-    }).displayOutput;
-    return { output, displayOutput, savedPath, cleanup, reference };
-}
-export function stepOutputFields(step, published, input) {
-    const cleanup = published.cleanup;
-    return {
-        finalOutput: step.outputMode === "file-only" ? published.displayOutput : published.output,
-        initialOutput: input.acceptance?.finalization ? input.initialOutput : undefined,
-        outputMode: step.outputMode ?? "inline",
-        outputReference: published.reference,
-        outputCleanup: cleanup,
-        outputSaveError: input.saveError,
-        savedOutputPath: cleanup && cleanup.action !== "skipped" ? undefined : published.savedPath,
-    };
-}

package/dist/runs/background/runner-step-record.js

@@ -1,45 +0,0 @@
-import * as fs from "node:fs";
-import { saveQuestionContract } from "../shared/supervisor-questions.js";
-export function nativeResultFields(execution, attempts) {
-    return {
-        accounting: attempts.find((attempt) => attempt.accounting?.state === "incomplete")?.accounting ??
-            execution.accounting,
-        nativeSessionId: execution.nativeSessionId,
-        terminalLeafId: execution.terminalLeafId,
-        terminalEntryId: execution.terminalEntryId,
-        auditPath: execution.auditPath,
-        auditSaveError: execution.auditSaveError,
-        agentProcessExit: execution.agentProcessExit,
-    };
-}
-/** Publishes immutable completed-step evidence after output preservation is finished. */
-export function saveStepRecord(result, input, paths) {
-    if (result.task === undefined || result.usage === undefined) {
-        throw new Error("Completed step evidence requires task and usage.");
-    }
-    if (paths) {
-        fs.writeFileSync(paths.outputPath, input.fullOutput, "utf-8");
-        fs.writeFileSync(paths.metadataPath, JSON.stringify({
-            runId: input.runId,
-            agent: result.agent,
-            task: input.task,
-            exitCode: result.exitCode,
-            interrupted: result.interrupted,
-            agentProcessExit: result.agentProcessExit,
-            error: result.error,
-            acceptance: result.acceptance,
-            initialOutput: result.initialOutput,
-            usage: result.usage,
-            model: result.model,
-            attemptedModels: result.attemptedModels,
-            modelAttempts: result.modelAttempts,
-            resourceLimitExceeded: result.resourceLimitExceeded,
-            skills: result.skills,
-            timestamp: Date.now(),
-        }, null, 2), "utf-8");
-    }
-    saveQuestionContract(input.runId, input.flatIndex, {
-        result: { ...result, task: result.task, usage: result.usage, finalOutput: result.finalOutput },
-        updatedAt: Date.now(),
-    });
-}

package/dist/runs/background/runner-step.js

@@ -1,112 +0,0 @@
-import { findLatestSessionFile } from "../../shared/utils.js";
-import { runModelAttempts, sumAttemptUsage } from "../shared/model-fallback.js";
-import { recordRun } from "../shared/run-history.js";
-import { resolveExecutionOutcome } from "../shared/acceptance.js";
-import { RunnerAttempt } from "./runner-attempt.js";
-import { RunnerFinalization } from "./runner-finalization.js";
-import { prepareRunnerStep } from "./runner-prepare-step.js";
-import { publishStepOutput, stepOutputFields } from "./runner-step-output.js";
-import { nativeResultFields, saveStepRecord } from "./runner-step-record.js";
-async function executePreparedStep(prepared, ctx) {
-    const { step, interruptSignal, verificationSignal, structuredRuntime, sessionDir, sessionEnabled, } = prepared;
-    const runner = new RunnerAttempt(step, ctx, {
-        interruptSignal,
-        verificationSignal,
-        effectiveStructuredOutput: structuredRuntime,
-        sessionEnabled,
-        sessionDir,
-    });
-    const candidates = step.modelCandidates;
-    const series = await runModelAttempts({
-        candidates: candidates !== undefined && candidates.length > 0 ? candidates : [step.model],
-        signal: verificationSignal,
-        runAttempt: (model) => runner.run(prepared.task, model),
-    });
-    const sessionFile = step.sessionFile ??
-        (sessionDir !== undefined && sessionDir.length > 0
-            ? (findLatestSessionFile(sessionDir) ?? undefined)
-            : undefined);
-    const finalization = new RunnerFinalization(step, runner, series.result, {
-        sessionFile,
-        cwd: step.cwd ?? ctx.cwd,
-        signal: verificationSignal,
-        structuredRuntime,
-        modelAttempts: series.modelAttempts,
-    });
-    const acceptance = await finalization.evaluate();
-    const outcome = finalization.includePreviousFailure(resolveExecutionOutcome({
-        result: finalization.execution,
-        acceptance,
-        signal: ctx.signal,
-        interruptSignal,
-    }));
-    return {
-        runner,
-        finalization,
-        initial: series.result,
-        attemptedModels: series.attemptedModels,
-        attemptNotes: series.notes,
-        acceptance,
-        outcome,
-        sessionFile,
-    };
-}
-/** Runs fallback attempts, acceptance review and output preservation in that order. */
-export async function runSingleStep(input, ctx) {
-    const startedAt = Date.now();
-    if (ctx.signal?.aborted === true) {
-        return { agent: input.agent, output: "", exitCode: 1, error: "Subagent cancelled." };
-    }
-    const prepared = prepareRunnerStep(input, ctx);
-    const execution = await executePreparedStep(prepared, ctx);
-    const { initial, finalization, runner, attemptedModels, outcome, acceptance, sessionFile } = execution;
-    const { step } = prepared;
-    const published = publishStepOutput(step, ctx, {
-        output: finalization.output,
-        acceptance,
-        resolvedOutput: finalization.resolvedOutput,
-        outcome,
-        attemptNotes: execution.attemptNotes,
-    });
-    const exitCode = outcome.exitCode ?? 1;
-    const usage = sumAttemptUsage(finalization.modelAttempts);
-    const progressSummary = {
-        toolCount: runner.toolCount,
-        tokens: usage.input + usage.output,
-        durationMs: Date.now() - startedAt,
-    };
-    const result = {
-        ...nativeResultFields(finalization.execution, finalization.modelAttempts),
-        agent: step.agent,
-        output: published.displayOutput,
-        exitCode,
-        error: outcome.error,
-        usage,
-        timedOut: outcome.timedOut,
-        task: step.task,
-        skills: step.skills,
-        ...stepOutputFields(step, published, {
-            acceptance,
-            initialOutput: finalization.initialOutput,
-            saveError: finalization.resolvedOutput.saveError,
-        }),
-        toolCalls: runner.toolCalls.length > 0 ? runner.toolCalls : undefined,
-        progressSummary,
-        sessionFile,
-        intercomTarget: ctx.childIntercomTarget,
-        model: initial.model,
-        attemptedModels: attemptedModels.length > 0 ? [...attemptedModels] : undefined,
-        modelAttempts: finalization.modelAttempts,
-        artifactPaths: prepared.artifactPaths,
-        interrupted: outcome.interrupted,
-        completionGuardTriggered: initial.completionGuardTriggered,
-        structuredOutput: finalization.structuredOutput,
-        structuredOutputPath: prepared.structuredRuntime?.outputPath,
-        structuredOutputSchemaPath: prepared.structuredRuntime?.schemaPath,
-        acceptance,
-        resourceLimitExceeded: outcome.resourceLimitExceeded,
-    };
-    recordRun(step.agent, step.task, exitCode, progressSummary.durationMs);
-    saveStepRecord(result, { runId: ctx.id, flatIndex: ctx.flatIndex, task: prepared.task, fullOutput: published.output }, prepared.artifactPaths);
-    return result;
-}