@fitchmultz/pi-subagents 0.49.1 → 0.50.0

package/dist/runs/background/runner-child-executor.js

@@ -1,166 +0,0 @@
-import * as path from "node:path";
-import { appendJsonl } from "../../shared/artifacts.js";
-import { buildControlEvent } from "../shared/subagent-control.js";
-import { flattenSteps } from "../shared/parallel-utils.js";
-import { markStepPaused, startRunnerStep, finishRunnerStep, runnerResultEvent, tokenUsageFromAttempts, } from "./runner-status.js";
-import { runSingleStep } from "./runner-step.js";
-/** Executes one scheduled child; shared workflow policy still owns scheduling and admission. */
-export class RunnerChildExecutor {
-    latestSessionFile;
-    config;
-    monitor;
-    lifecycle;
-    renderTask;
-    sessionEnabled;
-    constructor(config, monitor, lifecycle, renderTask) {
-        this.config = config;
-        this.monitor = monitor;
-        this.lifecycle = lifecycle;
-        this.renderTask = renderTask;
-        this.sessionEnabled =
-            (config.sessionDir !== undefined && config.sessionDir.length > 0) ||
-                config.share === true ||
-                flattenSteps(config.steps).some((step) => step.sessionFile !== undefined && step.sessionFile.length > 0);
-    }
-    async run(input) {
-        const { task, flatIndex } = input;
-        const startedAt = startRunnerStep(this.monitor.statusPayload, task, {
-            asyncDir: this.config.asyncDir,
-            index: flatIndex,
-            sequential: input.sequential,
-            resetTiming: input.resetTiming,
-        });
-        this.monitor.writeStatusPayload();
-        this.append({
-            type: "subagent.step.started",
-            ts: startedAt,
-            runId: this.config.id,
-            stepIndex: flatIndex,
-            agent: task.agent,
-        });
-        const result = await runSingleStep({ ...task, task: this.renderTask(task.task, input.item) }, this.stepContext(input));
-        this.lifecycle.register(flatIndex, undefined);
-        if (input.trackSession === true &&
-            task.sessionFile !== undefined &&
-            task.sessionFile.length > 0) {
-            this.latestSessionFile = task.sessionFile;
-        }
-        // Sequential workflow outputs must be admitted before terminal step status is published.
-        input.beforeFinish?.(result);
-        this.finish(input, result, startedAt);
-        return input.sequential === true ? result : { ...result, skipped: false };
-    }
-    stepContext(input) {
-        const { config, monitor, lifecycle } = this;
-        const index = input.flatIndex;
-        const childTarget = monitor.childTarget(index);
-        return {
-            nativeFinalization: config.runtimeVersion === 2,
-            worktreePath: input.worktreePath,
-            cwd: input.taskCwd,
-            sessionEnabled: this.sessionEnabled,
-            sessionDir: input.sessionDir,
-            artifactsDir: config.artifactsDir,
-            id: config.id,
-            flatIndex: index,
-            flatStepCount: input.flatStepCount,
-            outputFile: path.join(config.asyncDir, `output-${index}.log`),
-            childIntercomTarget: childTarget,
-            orchestratorIntercomTarget: childTarget === undefined || childTarget.length === 0
-                ? undefined
-                : config.controlIntercomTarget,
-            nestedRoute: config.nestedRoute,
-            projectTrust: config.projectTrust,
-            rootSessionId: config.rootSessionId,
-            signal: lifecycle.cancellation.signal,
-            interruptSignal: input.interruptSignal,
-            registerInterrupt: (interrupt) => {
-                lifecycle.register(index, interrupt);
-            },
-            onAttemptStart: (attempt) => {
-                monitor.updateStepModel(index, attempt.model, attempt.thinking);
-            },
-            onChildEvent: (event, mutation) => {
-                monitor.updateStepFromChildEvent(index, event, mutation);
-            },
-        };
-    }
-    finish(input, result, startedAt) {
-        const endedAt = finishRunnerStep(this.monitor.statusPayload, result, {
-            index: input.flatIndex,
-            startedAt,
-            sequential: input.sequential,
-        });
-        this.monitor.writeStatusPayload();
-        this.append({
-            type: runnerResultEvent(result),
-            ts: endedAt,
-            runId: this.config.id,
-            stepIndex: input.flatIndex,
-            agent: input.task.agent,
-            exitCode: result.exitCode,
-            durationMs: endedAt - startedAt,
-            interrupted: result.interrupted,
-            agentProcessExit: result.agentProcessExit,
-            ...(input.sequential === true
-                ? { tokens: tokenUsageFromAttempts(result.modelAttempts) }
-                : {}),
-            resourceLimitExceeded: result.resourceLimitExceeded,
-        });
-        if (input.notifyCompletionGuard === true && result.completionGuardTriggered === true) {
-            this.monitor.appendControlEvent(buildControlEvent({
-                from: this.monitor.statusPayload.steps[input.flatIndex].activityState,
-                to: "needs_attention",
-                runId: this.config.id,
-                agent: input.task.agent,
-                index: input.flatIndex,
-                ts: endedAt,
-                message: `${input.task.agent} completed without making edits for an implementation task`,
-                reason: "completion_guard",
-            }));
-        }
-    }
-    stop(task, index, reason) {
-        const now = Date.now();
-        const step = this.monitor.statusPayload.steps[index];
-        const paused = reason === "interrupted";
-        const error = `Skipped due to ${reason}`;
-        const exitCode = paused ? 0 : -1;
-        if (paused) {
-            markStepPaused(step, now);
-        }
-        else {
-            Object.assign(step, {
-                status: "failed",
-                error,
-                startedAt: now,
-                endedAt: now,
-                durationMs: 0,
-                exitCode,
-            });
-        }
-        this.monitor.statusPayload.lastUpdate = now;
-        this.monitor.writeStatusPayload();
-        this.append({
-            type: paused ? "subagent.step.paused" : "subagent.step.failed",
-            ts: now,
-            runId: this.config.id,
-            stepIndex: index,
-            agent: task.agent,
-            exitCode,
-            interrupted: paused,
-            durationMs: 0,
-        });
-        return {
-            agent: task.agent,
-            output: error,
-            error,
-            exitCode,
-            interrupted: paused,
-            skipped: true,
-        };
-    }
-    append(event) {
-        appendJsonl(path.join(this.config.asyncDir, "events.jsonl"), JSON.stringify(event));
-    }
-}

package/dist/runs/background/runner-child-observer.js

@@ -1,197 +0,0 @@
-import { extractTextFromContent, extractToolArgsPreview } from "../../shared/utils.js";
-import { buildControlEvent } from "../shared/subagent-control.js";
-import { createMutatingFailureState, recordMutatingFailure, resetMutatingFailureState, resolveCurrentPath, shouldEscalateMutatingFailures, summarizeRecentMutatingFailures, } from "../shared/mutating-tool-guard.js";
-import { stripAcceptanceReport } from "../shared/acceptance.js";
-import { updateStreamingText } from "../shared/streaming-text.js";
-import { appendRecentStepOutput, clearStepCurrentActivity, } from "./runner-status.js";
-function messageUsage(message) {
-    if (typeof message !== "object" || message === null || !("usage" in message)) {
-        return;
-    }
-    const usage = message.usage;
-    if (typeof usage !== "object" || usage === null) {
-        return;
-    }
-    return {
-        input: "input" in usage && typeof usage.input === "number" ? usage.input : 0,
-        output: "output" in usage && typeof usage.output === "number" ? usage.output : 0,
-    };
-}
-/** Owns the live event projection and mutating-tool failure windows. */
-export class RunnerChildObserver {
-    statusPayload;
-    controlConfig;
-    id;
-    hooks;
-    mutatingFailureStates;
-    mutatingFailureWindowMs = 5 * 60_000;
-    constructor(statusPayload, config, hooks) {
-        this.statusPayload = statusPayload;
-        this.controlConfig = config.controlConfig;
-        this.id = config.id;
-        this.hooks = hooks;
-        this.mutatingFailureStates = statusPayload.steps.map(() => createMutatingFailureState());
-        this.syncTopLevelCurrentTool();
-    }
-    expandChildren(flatIndex, count) {
-        this.mutatingFailureStates.splice(flatIndex, 1, ...Array.from({ length: count }, () => createMutatingFailureState()));
-    }
-    syncTopLevelCurrentTool() {
-        const active = this.statusPayload.state === "running" || this.statusPayload.state === "queued"
-            ? this.statusPayload.steps
-                .filter((step) => step.status === "running" &&
-                typeof step.currentTool === "string" &&
-                step.currentTool.length > 0)
-                .sort((left, right) => (right.currentToolStartedAt ?? 0) - (left.currentToolStartedAt ?? 0))
-                .at(0)
-            : undefined;
-        this.statusPayload.currentTool = active?.currentTool;
-        this.statusPayload.currentToolStartedAt = active?.currentToolStartedAt;
-        this.statusPayload.currentPath = active?.currentPath;
-    }
-    updateStepFromChildEvent(flatIndex, event, toolSnapshot) {
-        const step = this.statusPayload.steps.at(flatIndex);
-        if (!step) {
-            return;
-        }
-        const now = Date.now();
-        this.statusPayload.currentStep = flatIndex;
-        if (step.activityState === "needs_attention") {
-            step.activityState = undefined;
-            this.hooks.clearAttention(flatIndex);
-            this.statusPayload.activityState = this.statusPayload.steps.some((candidate) => candidate.activityState === "needs_attention")
-                ? "needs_attention"
-                : undefined;
-        }
-        step.streamingText = updateStreamingText(step.streamingText, event);
-        this.recordChildActivity(flatIndex, event, toolSnapshot, now);
-        if (event.type === "tool_execution_start" || event.type === "tool_execution_end") {
-            this.syncTopLevelCurrentTool();
-        }
-        step.lastActivityAt = now;
-        this.statusPayload.lastActivityAt = now;
-        this.statusPayload.lastUpdate = now;
-        this.hooks.scheduleWrite();
-    }
-    recordChildActivity(flatIndex, event, toolSnapshot, now) {
-        const step = this.statusPayload.steps[flatIndex];
-        switch (event.type) {
-            case "tool_execution_start":
-                this.recordToolStart(flatIndex, event, now);
-                return;
-            case "tool_execution_end":
-                if (step.currentTool !== undefined && step.currentTool.length > 0) {
-                    step.recentTools ??= [];
-                    step.recentTools.push({
-                        tool: step.currentTool,
-                        args: step.currentToolArgs ?? "",
-                        endMs: now,
-                    });
-                }
-                clearStepCurrentActivity(step);
-                return;
-            case "message_end":
-                this.recordCompletedMessage(flatIndex, event, toolSnapshot, now);
-                return;
-            case undefined:
-            default:
-                return;
-        }
-    }
-    recordToolStart(flatIndex, event, now) {
-        if (event.toolName === undefined || event.toolName.length === 0) {
-            return;
-        }
-        const step = this.statusPayload.steps[flatIndex];
-        step.toolCount = (step.toolCount ?? 0) + 1;
-        step.currentTool = event.toolName;
-        step.currentToolArgs = extractToolArgsPreview(event.args ?? {});
-        step.currentToolStartedAt = now;
-        step.currentPath = resolveCurrentPath(event.toolName, event.args);
-        this.statusPayload.toolCount = (this.statusPayload.toolCount ?? 0) + 1;
-    }
-    recordCompletedMessage(flatIndex, event, toolSnapshot, now) {
-        const step = this.statusPayload.steps[flatIndex];
-        const message = event.message;
-        if (message?.role === "toolResult") {
-            const text = extractTextFromContent(message.content);
-            appendRecentStepOutput(step, text.split("\n").slice(-10));
-            if (toolSnapshot?.mutates === true) {
-                this.recordMutationResult(flatIndex, toolSnapshot, text, now);
-            }
-        }
-        else if (message?.role === "assistant") {
-            appendRecentStepOutput(step, stripAcceptanceReport(extractTextFromContent(message.content)).split("\n").slice(-10));
-            step.turnCount = (step.turnCount ?? 0) + 1;
-            const usage = messageUsage(message);
-            if (usage) {
-                this.recordUsage(flatIndex, usage);
-            }
-            this.statusPayload.turnCount = Math.max(this.statusPayload.turnCount ?? 0, step.turnCount);
-        }
-    }
-    recordUsage(flatIndex, usage) {
-        const step = this.statusPayload.steps[flatIndex];
-        const { input, output } = usage;
-        const previousInput = step.tokens?.input ?? 0;
-        const previousOutput = step.tokens?.output ?? 0;
-        step.tokens = {
-            input: previousInput + input,
-            output: previousOutput + output,
-            total: previousInput + previousOutput + input + output,
-        };
-        const totalInput = this.statusPayload.totalTokens?.input ?? 0;
-        const totalOutput = this.statusPayload.totalTokens?.output ?? 0;
-        this.statusPayload.totalTokens = {
-            input: totalInput + input,
-            output: totalOutput + output,
-            total: totalInput + totalOutput + input + output,
-        };
-    }
-    recordMutationResult(flatIndex, snapshot, text, now) {
-        const state = this.mutatingFailureStates[flatIndex];
-        if (!snapshot.errored) {
-            resetMutatingFailureState(state);
-            return;
-        }
-        recordMutatingFailure(state, {
-            tool: snapshot.tool,
-            path: snapshot.path,
-            error: text
-                .split("\n")
-                .find((line) => line.trim().length > 0)
-                ?.trim()
-                .slice(0, 180) ?? "mutating tool failed",
-            ts: now,
-        }, this.mutatingFailureWindowMs);
-        const step = this.statusPayload.steps[flatIndex];
-        if (!this.controlConfig.enabled ||
-            !shouldEscalateMutatingFailures(state, this.controlConfig.failedToolAttemptsBeforeAttention) ||
-            step.activityState === "needs_attention") {
-            return;
-        }
-        const previous = step.activityState;
-        step.activityState = "needs_attention";
-        this.statusPayload.activityState = "needs_attention";
-        this.hooks.notify(buildControlEvent({
-            type: "needs_attention",
-            from: previous,
-            to: "needs_attention",
-            runId: this.id,
-            agent: step.agent,
-            index: flatIndex,
-            ts: now,
-            message: `${step.agent} needs attention after repeated mutating tool failures`,
-            reason: "tool_failures",
-            turns: step.turnCount,
-            tokens: step.tokens?.total,
-            toolCount: step.toolCount,
-            currentTool: snapshot.tool,
-            currentToolDurationMs: snapshot.startedAt === undefined || snapshot.startedAt === 0
-                ? undefined
-                : Math.max(0, now - snapshot.startedAt),
-            currentPath: snapshot.path,
-            recentFailureSummary: summarizeRecentMutatingFailures(state),
-        }));
-    }
-}

package/dist/runs/background/runner-completion-summary.js

@@ -1,71 +0,0 @@
-import { truncateOutput, } from "../../shared/types.js";
-import { acceptanceHumanAction } from "../shared/acceptance.js";
-import { appendWorktreeSummary } from "../shared/worktree.js";
-function childText(result) {
-    if (result.error !== undefined &&
-        result.error.length > 0 &&
-        !result.output.includes(result.error)) {
-        return `${result.error}\n${result.output}`.trim();
-    }
-    return result.output;
-}
-export function runLabel(mode) {
-    if (mode === "parallel") {
-        return "Parallel run";
-    }
-    return mode === "chain" ? "Chain" : "Run";
-}
-export function completionSummary(input) {
-    const onlyResult = input.results.at(0);
-    let summary = input.mode === "single" && input.results.length === 1 && onlyResult !== undefined
-        ? childText(onlyResult)
-        : input.results.map((result) => `${result.agent}:\n${childText(result)}`).join("\n\n");
-    if (input.error !== undefined && input.error.length > 0 && !summary.includes(input.error)) {
-        summary = `${input.error}\n\n${summary}`.trim();
-    }
-    if (input.timedOut === true) {
-        summary = [`${runLabel(input.mode)} timed out.`, summary]
-            .filter((line) => line.length > 0)
-            .join("\n\n");
-    }
-    if (input.worktreeSummaries.length > 0) {
-        summary = appendWorktreeSummary(summary, input.worktreeSummaries.join("\n\n"));
-    }
-    return summary;
-}
-export function truncateStepResult(result, limits) {
-    const outputPath = result.artifactPaths?.outputPath;
-    const reference = result.outputMode === "file-only" && result.exitCode === 0 ? result.outputReference : undefined;
-    const childOutput = reference !== undefined
-        ? { text: reference.message, truncated: false }
-        : truncateOutput(result.output, limits, outputPath);
-    let finalOutput = result.finalOutput;
-    if (reference !== undefined) {
-        finalOutput = reference.message;
-    }
-    else if (finalOutput !== undefined) {
-        finalOutput = truncateOutput(finalOutput, limits, outputPath).text;
-    }
-    const initialOutput = result.initialOutput === undefined
-        ? undefined
-        : truncateOutput(result.initialOutput, limits, outputPath).text;
-    return Object.assign({}, result, {
-        output: childOutput.text,
-        finalOutput,
-        initialOutput,
-        truncated: result.truncated === true || childOutput.truncated ? true : undefined,
-    });
-}
-export function terminalSummary(input) {
-    if (input.state === "blocked") {
-        const actions = input.results
-            .map((result) => acceptanceHumanAction(result.acceptance))
-            .filter((action) => action !== undefined && action.length > 0);
-        return `Needs your action — acceptance incomplete.\n${actions.join("\n")}`;
-    }
-    if (input.state === "paused") {
-        const warning = input.setupCleanupWarning.length > 0 ? `\n\n${input.setupCleanupWarning}` : "";
-        return `Paused after interrupt. Waiting for explicit next action.${warning}`;
-    }
-    return input.summary;
-}

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

@@ -1,211 +0,0 @@
-import * as path from "node:path";
-import { writeAtomicJson } from "../../shared/atomic-json.js";
-import { appendJsonl } from "../../shared/artifacts.js";
-import { DEFAULT_MAX_OUTPUT, truncateOutput, } from "../../shared/types.js";
-import { saveAsyncRunResult } from "../shared/supervisor-questions.js";
-import { flattenSteps } from "../shared/parallel-utils.js";
-import { shareRunnerSession, writeRunLog } from "./runner-reporting.js";
-import { markStepPaused } from "./runner-status.js";
-import { completionSummary, terminalSummary, truncateStepResult, } from "./runner-completion-summary.js";
-class RunnerCompletion {
-    config;
-    evidence;
-    monitor;
-    lifecycle;
-    eventsPath;
-    outputLimits;
-    resultMode;
-    fullSummary;
-    summary;
-    truncated;
-    constructor(config, evidence, monitor, lifecycle) {
-        this.config = config;
-        this.evidence = evidence;
-        this.monitor = monitor;
-        this.lifecycle = lifecycle;
-        this.eventsPath = path.join(config.asyncDir, "events.jsonl");
-        this.outputLimits = { ...DEFAULT_MAX_OUTPUT, ...config.maxOutput };
-        this.resultMode = config.resultMode ?? monitor.statusPayload.mode;
-        this.fullSummary = completionSummary({
-            mode: this.resultMode,
-            results: evidence.results,
-            error: monitor.statusPayload.error,
-            timedOut: monitor.statusPayload.timedOut,
-            worktreeSummaries: evidence.worktreeSummaries,
-        });
-        const onlyResult = evidence.results.at(0);
-        const referenceOnly = this.resultMode === "single" &&
-            evidence.results.length === 1 &&
-            onlyResult?.outputMode === "file-only" &&
-            onlyResult.exitCode === 0 &&
-            onlyResult.outputReference !== undefined;
-        const output = referenceOnly
-            ? { text: this.fullSummary, truncated: false }
-            : truncateOutput(this.fullSummary, this.outputLimits, evidence.results.at(-1)?.artifactPaths?.outputPath);
-        this.summary = output.text;
-        this.truncated = output.truncated;
-    }
-    pausePendingSteps(endedAt) {
-        if (!this.lifecycle.interrupted) {
-            return;
-        }
-        this.monitor.statusPayload.steps.forEach((step, stepIndex) => {
-            if (step.status !== "pending") {
-                return;
-            }
-            markStepPaused(step, endedAt);
-            appendJsonl(this.eventsPath, JSON.stringify({
-                type: "subagent.step.paused",
-                ts: endedAt,
-                runId: this.config.id,
-                stepIndex,
-                agent: step.agent,
-                interrupted: true,
-                durationMs: 0,
-            }));
-        });
-    }
-    finalRunState() {
-        const status = this.monitor.statusPayload;
-        if (status.steps.some((step) => step.status === "failed") ||
-            (status.error !== undefined && status.error.length > 0) ||
-            this.lifecycle.cancellation.signal.aborted) {
-            return "failed";
-        }
-        if (status.steps.some((step) => step.status === "blocked")) {
-            return "blocked";
-        }
-        if (this.lifecycle.interrupted || status.steps.some((step) => step.status === "paused")) {
-            return "paused";
-        }
-        return this.evidence.workflowComplete ? "complete" : "failed";
-    }
-    updateFailure() {
-        const status = this.monitor.statusPayload;
-        if (status.state !== "failed" || (status.error !== undefined && status.error.length > 0)) {
-            return;
-        }
-        const failedStep = status.steps.find((step) => step.status === "failed");
-        if (failedStep !== undefined && failedStep.agent.length > 0) {
-            status.error = `Step failed: ${failedStep.agent}`;
-        }
-        else if (this.lifecycle.cancellation.signal.aborted) {
-            status.error = "Subagent cancelled.";
-        }
-    }
-    publishStatus(endedAt, share) {
-        const status = this.monitor.statusPayload;
-        status.state = this.finalRunState();
-        status.activityState = undefined;
-        status.currentTool = undefined;
-        status.currentToolStartedAt = undefined;
-        status.currentPath = undefined;
-        status.endedAt = endedAt;
-        status.lastUpdate = endedAt;
-        status.sessionFile = share.sessionFile;
-        status.shareUrl = share.shareUrl;
-        status.gistUrl = share.gistUrl;
-        status.shareError = share.shareError;
-        this.updateFailure();
-        this.monitor.writeStatusPayload();
-        appendJsonl(this.eventsPath, JSON.stringify({
-            type: "subagent.run.completed",
-            ts: endedAt,
-            runId: this.config.id,
-            status: status.state,
-            durationMs: endedAt - this.evidence.overallStartTime,
-        }));
-        writeRunLog(path.join(this.config.asyncDir, `subagent-log-${this.config.id}.md`), {
-            id: this.config.id,
-            mode: status.mode,
-            cwd: this.config.cwd,
-            startedAt: this.evidence.overallStartTime,
-            endedAt,
-            steps: status.steps.map((step) => ({
-                agent: step.agent,
-                status: step.status,
-                durationMs: step.durationMs,
-            })),
-            summary: this.fullSummary,
-            truncated: false,
-            artifactsDir: this.config.artifactsDir,
-            sessionFile: share.sessionFile,
-            shareUrl: share.shareUrl,
-            shareError: share.shareError,
-        });
-    }
-    agentName() {
-        const steps = flattenSteps(this.config.steps);
-        const first = steps.at(0);
-        if (steps.length === 1 && first !== undefined) {
-            return first.agent;
-        }
-        const names = steps.map((step) => step.agent);
-        return this.resultMode === "parallel"
-            ? `parallel:${names.join("+")}`
-            : `chain:${names.join("->")}`;
-    }
-    writeResult(endedAt, share) {
-        const status = this.monitor.statusPayload;
-        const { config, evidence } = this;
-        const exitCode = status.state === "failed" ? 1 : 0;
-        const resultData = {
-            id: config.id,
-            runtimeVersion: config.runtimeVersion,
-            maxOutput: this.outputLimits,
-            error: status.error,
-            timedOut: status.timedOut,
-            agent: this.agentName(),
-            mode: this.resultMode,
-            success: status.state === "complete",
-            state: status.state,
-            summary: terminalSummary({
-                state: status.state,
-                results: evidence.results,
-                summary: this.summary,
-                setupCleanupWarning: evidence.setupCleanupWarning,
-            }),
-            results: evidence.results.map((result) => truncateStepResult(result, this.outputLimits)),
-            outputs: evidence.outputs,
-            workflowGraph: status.workflowGraph,
-            exitCode: status.timedOut === true ? 124 : exitCode,
-            timestamp: endedAt,
-            durationMs: endedAt - evidence.overallStartTime,
-            truncated: this.truncated,
-            artifactsDir: config.artifactsDir,
-            cwd: config.cwd,
-            asyncDir: config.asyncDir,
-            sessionId: config.sessionId ?? undefined,
-            sessionFile: share.sessionFile,
-            intercomTarget: config.controlIntercomTarget,
-            shareUrl: share.shareUrl,
-            gistUrl: share.gistUrl,
-            shareError: share.shareError,
-            ...(config.taskIndex !== undefined && { taskIndex: config.taskIndex }),
-            ...(config.totalTasks !== undefined && { totalTasks: config.totalTasks }),
-        };
-        const saved = saveAsyncRunResult(config.id, resultData);
-        resultData.completionId = saved.completionId;
-        resultData.recordVersion = 3;
-        if (config.runtimeVersion !== 2 ||
-            path.resolve(config.resultPath) !== path.resolve(config.asyncDir, "result.json")) {
-            writeAtomicJson(config.resultPath, resultData);
-        }
-    }
-    async complete() {
-        const share = await shareRunnerSession(this.config, this.evidence.latestSessionFile);
-        this.lifecycle.dispose();
-        const endedAt = Date.now();
-        this.pausePendingSteps(endedAt);
-        this.publishStatus(endedAt, share);
-        try {
-            this.writeResult(endedAt, share);
-        }
-        catch (error) {
-            console.error(`Failed to write result file ${this.config.resultPath}:`, error);
-        }
-    }
-}
-export async function completeRunner(config, evidence, monitor, lifecycle) {
-    await new RunnerCompletion(config, evidence, monitor, lifecycle).complete();
-}

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

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

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

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