cloving 1.1.0 → 1.3.0

package/dist/src/cli/render.js

@@ -1,5 +1,7 @@
-import { priceText, usageText, totalsSuffix } from "./usage-render.js";
+import { priceText, usageText, totalsSuffix, attemptTexts, } from "./usage-render.js";
 import { record } from "../protocol.js";
+import { workflowRefusals } from "../workflow-refusals.js";
+import { commandText, shownCommands } from "./command-effects.js";
 function show(value) {
     return typeof value === "string" ? value : JSON.stringify(value);
 }
@@ -19,6 +21,9 @@ function hidden(character) {
     const code = character.codePointAt(0) ?? 0;
     return hiddenRanges.some(([first, last]) => code >= first && code <= last);
 }
+export function oneLine(value) {
+    return Array.from(show(value), (character) => hidden(character) ? escaped(character) : character).join("");
+}
 function visible(value) {
     return show(value)
         .split("\n")
@@ -57,7 +62,26 @@ function admitted(result) {
     ];
 }
 function runLine(run) {
-    return `  ${show(part(run, "runId"))}  ${show(part(run, "workflowId"))}  ${show(part(run, "condition"))}  revision ${show(part(run, "revision"))}  latest at ${show(part(run, "latestAt") ?? "none")}`;
+    const line = `  ${show(part(run, "runId"))}  ${show(part(run, "workflowId"))}  ${show(part(run, "condition"))}  revision ${show(part(run, "revision"))}  latest at ${show(part(run, "latestAt") ?? "none")}`;
+    return [
+        line,
+        ...ciLines(run).map((notice) => `    ${notice}`),
+        ...chainLines(run).map((link) => `    ${link}`),
+    ].join("\n");
+}
+function chainLines(run) {
+    return [
+        ...(typeof part(run, "awaitedRunId") === "string"
+            ? [`Awaited run: ${visible(part(run, "awaitedRunId"))}`]
+            : []),
+        `Parent run: ${visible(part(run, "parentRunId") ?? "none")}`,
+        `Chain: ${visible(part(run, "chainId") ?? part(run, "runId") ?? "none")}`,
+        `Child runs: ${visible(listing(part(run, "childRunIds")))}`,
+    ];
+}
+function ciLines(run) {
+    const reruns = part(run, "ciReruns");
+    return (Array.isArray(reruns) ? reruns : []).map((rerun) => `CI rerun after a failed check: workflow ${visible(part(rerun, "run"))}, commit ${visible(part(rerun, "commit"))}`);
 }
 function ended(run) {
     return ["completed", "failed", "cancelled"].includes(show(run["state"]));
@@ -82,8 +106,16 @@ function runList(result) {
     const runs = result["runs"];
     const lines = Array.isArray(runs) ? runs.map(runLine) : [];
     const hiddenRuns = result["hiddenRuns"];
+    const refusals = workflowRefusals(result["workflowRefusals"]);
     return [
         `Workflows: ${visible(listing(result["workflows"]))}`,
+        ...queueLines(result["queue"]),
+        ...(refusals.length === 0
+            ? []
+            : [
+                "Refused workflows:",
+                ...refusals.map((entry) => `  ${entry.scope} ${entry.label}: ${entry.codes.join(", ")}`),
+            ]),
         "Runs:",
         ...(lines.length === 0 ? ["  none"] : lines),
         ...(typeof hiddenRuns === "number" && hiddenRuns > 0
@@ -93,6 +125,24 @@ function runList(result) {
             : []),
     ];
 }
+export function queueLines(value) {
+    const queue = record(value);
+    if (queue === undefined)
+        return [];
+    const skipped = queue["skipped"];
+    return [
+        `Queue: ${visible(queue["busy"])} of ${visible(queue["lanes"])} lanes busy`,
+        ...(Array.isArray(skipped)
+            ? skipped.map((item) => {
+                const dependencies = part(item, "dependencies");
+                const needs = Array.isArray(dependencies)
+                    ? `; needs ${dependencies.map(visible).join(", ")}`
+                    : "";
+                return `Skipped ticket ${visible(part(item, "ticketId"))}: ${visible(part(item, "reason"))}${needs}`;
+            })
+            : []),
+    ];
+}
 function observation(value) {
     if (record(value) === undefined)
         return "none";
@@ -101,44 +151,55 @@ function observation(value) {
 function feedbackLines(value) {
     return (Array.isArray(value) ? value : []).map((item) => `Feedback of ${show(part(item, "decisionId"))}: ${visible(part(item, "text"))}`);
 }
-function outcome(value) {
+function outcomeLines(value) {
     if (record(value) === undefined)
-        return "none";
+        return ["Outcome: none"];
     const reason = part(value, "reason");
     const kind = visible(part(value, "kind"));
-    return typeof reason === "string" ? `${kind}: ${visible(reason)}` : kind;
+    return [
+        `Outcome: ${typeof reason === "string" ? `${kind}: ${visible(reason)}` : kind}`,
+        ...(typeof part(value, "promotionId") === "string"
+            ? [`Promotion: ${visible(part(value, "promotionId"))}`]
+            : []),
+        ...(typeof part(value, "ticketStatus") === "string"
+            ? [`Ticket status: ${visible(part(value, "ticketStatus"))}`]
+            : []),
+        ...(part(value, "issueUpdate") === "failed"
+            ? ["Issue status update failed; check the GitHub operation."]
+            : []),
+    ];
+}
+function labelled(label, value) {
+    return typeof value === "string" ? [`  ${label}: ${visible(value)}`] : [];
 }
 function workerLines(value) {
     return (Array.isArray(value) ? value : []).flatMap((turn) => [
         `Worker turn ${visible(part(turn, "operationId"))}: ${priceText(part(turn, "costUsd"), part(turn, "estimatedCostUsd"))}`,
+        ...labelled("Harness", part(turn, "harness")),
+        ...labelled("Model", part(turn, "model")),
         `  ${usageText(part(turn, "usage"))}`,
+        ...attemptTexts(part(turn, "attempts")).map((text) => `  ${oneLine(text)}`),
+        ...modelLines(part(turn, "attempts")),
+        ...labelled("Report", part(turn, "summary")),
     ]);
 }
-export function statusJson(result) {
-    const run = record(result["run"]);
-    if (result["kind"] !== "run-status" || run === undefined)
-        return result;
-    const turns = run["workerTurns"];
-    return {
-        ...result,
-        run: {
-            ...run,
-            costDisplay: priceText(run["claudeCostUsd"], run["estimatedCostUsd"]),
-            ...(Array.isArray(turns)
-                ? {
-                    workerTurns: turns.map((turn) => {
-                        const fields = record(turn);
-                        if (fields === undefined)
-                            return turn;
-                        return {
-                            ...fields,
-                            costDisplay: priceText(fields["costUsd"], fields["estimatedCostUsd"]),
-                        };
-                    }),
-                }
-                : {}),
-        },
-    };
+function modelLines(attempts) {
+    if (!Array.isArray(attempts))
+        return [];
+    return attempts.flatMap((attempt) => {
+        const models = part(attempt, "models");
+        if (!Array.isArray(models))
+            return [];
+        return models.map((model) => `  ${visible(part(model, "model"))}: ${usageText(part(model, "usage"))}`);
+    });
+}
+export { statusJson } from "./usage-render.js";
+function inputText(value) {
+    const text = visible(record(value) ?? null);
+    const characters = Array.from(text);
+    return characters.length > 200
+        ? `${characters.slice(0, 200).join("")}…`
+        : text;
 }
 export function runStatus(result) {
     const run = result["run"];
@@ -150,17 +211,11 @@ export function runStatus(result) {
         `Run ${show(part(run, "runId"))} (${show(part(run, "workflowId"))})`,
         `Title: ${visible(part(run, "title") ?? "none")}`,
         `State: ${show(part(run, "state"))}`,
-        `Outcome: ${outcome(part(run, "outcome"))}`,
-        ...(typeof part(part(run, "outcome"), "ticketStatus") === "string"
-            ? [
-                `Ticket status: ${visible(part(part(run, "outcome"), "ticketStatus"))}`,
-            ]
-            : []),
-        ...(part(part(run, "outcome"), "issueUpdate") === "failed"
-            ? ["Issue status update failed; check the GitHub operation."]
-            : []),
+        ...outcomeLines(part(run, "outcome")),
+        ...ciLines(run),
         `Condition: ${show(part(run, "condition"))}`,
         `Reason: ${show(part(reason, "code"))}: ${show(part(reason, "detail"))}`,
+        `Input: ${inputText(part(run, "input"))}`,
         `Revision: ${show(part(run, "revision"))}, latest sequence ${show(part(run, "latestSequence"))}`,
         `Latest at: ${show(part(run, "latestAt") ?? "none")}`,
         `Pending decisions: ${listing(part(run, "pendingDecisions"))}`,
@@ -170,11 +225,19 @@ export function runStatus(result) {
         `Cost${suffix}: ${priceText(part(run, "claudeCostUsd"), part(run, "estimatedCostUsd"))}`,
         `Token usage${suffix}: ${usageText(part(run, "usage"))}`,
         ...workerLines(part(run, "workerTurns")),
+        ...shownCommands(part(run, "commandEffects")).map((effect) => visible(commandText(effect))),
         `Next action: ${show(part(run, "nextAction") ?? "none")}${at === null ? "" : ` at ${show(at)}`}`,
         `Human input can help: ${part(run, "humanInputCanHelp") === true ? "yes" : "no"}`,
         ...feedbackLines(part(run, "feedback")),
+        ...decidedLines(part(run, "decisions")),
+        ...chainLines(run),
     ];
 }
+function decidedLines(value) {
+    if (!Array.isArray(value))
+        return [];
+    return value.map((decision) => `Decision ${visible(part(decision, "decisionId"))}: ${visible(part(decision, "decision"))} by ${visible(part(decision, "actor"))}`);
+}
 function binding(decision) {
     return `--expected-revision ${show(part(decision, "revision"))} --generation ${show(part(decision, "generation"))} --subject-digest ${show(part(decision, "subjectDigest"))}`;
 }

package/dist/src/cli/report-github.d.ts

@@ -0,0 +1,18 @@
+import type { ReportDatum } from "../report-statistics.ts";
+import type { WatchPrSettings } from "./watch-pr-settings.ts";
+export interface ReportGithub {
+    readonly observedSince: number | null;
+    readonly issues: readonly ReportDatum[] | null;
+    readonly pulls: readonly ReportDatum[] | null;
+    readonly sources: Readonly<Record<"issues" | "pulls" | "history", {
+        readonly status: string;
+        readonly reason?: string;
+    }>>;
+}
+interface GithubReportInput {
+    readonly since: string;
+    readonly settings?: WatchPrSettings;
+    readonly retryMilliseconds?: number;
+}
+export declare function readReportGithub(input: GithubReportInput): Promise<ReportGithub>;
+export {};

package/dist/src/cli/report-github.js

@@ -0,0 +1,200 @@
+export async function readReportGithub(input) {
+    const reader = await repositoryReader(input).catch(() => null);
+    if (reader === null)
+        return {
+            observedSince: null,
+            issues: null,
+            pulls: null,
+            sources: {
+                issues: { status: "unavailable", reason: "configuration-or-identity" },
+                pulls: { status: "unavailable", reason: "configuration-or-identity" },
+                history: { status: "unavailable", reason: "configuration-or-identity" },
+            },
+        };
+    const [issues, pulls, history] = await Promise.allSettled([
+        issuesOf(reader, input.since),
+        pullsOf(reader, input.since),
+        repositoryCreatedAt(reader),
+    ]);
+    return {
+        observedSince: history.status === "fulfilled" ? history.value : null,
+        issues: issues.status === "fulfilled" ? issues.value : null,
+        pulls: pulls.status === "fulfilled" ? pulls.value : null,
+        sources: {
+            issues: source(issues),
+            pulls: source(pulls),
+            history: source(history),
+        },
+    };
+}
+import { record } from "../protocol.js";
+import { githubRetry } from "./github-retry.js";
+import { prRepository } from "./watch-pr-identity.js";
+function commandOf(value) {
+    const command = JSON.parse(value ?? '["gh"]');
+    if (!Array.isArray(command) ||
+        command.length === 0 ||
+        !command.every((part) => typeof part === "string" && part !== "" && !part.includes("\0")))
+        throw new Error("configuration");
+    return command.map(String);
+}
+function rows(value) {
+    if (!Array.isArray(value))
+        throw new Error("response");
+    return value.map((item) => {
+        const row = record(item);
+        if (row === undefined)
+            throw new Error("response");
+        return row;
+    });
+}
+function identity(row, context) {
+    const { repository, kind } = context;
+    const number = row["number"];
+    const url = row["html_url"];
+    if (typeof number !== "number" ||
+        !Number.isSafeInteger(number) ||
+        number <= 0 ||
+        typeof url !== "string" ||
+        url.toLowerCase() !==
+            `https://${repository.host}/${repository.owner}/${repository.repository}/${kind}/${String(number)}`)
+        throw new Error("identity");
+    return number;
+}
+function timestamp(value) {
+    if (typeof value !== "string" || !Number.isFinite(Date.parse(value)))
+        throw new Error("response");
+    return Date.parse(value);
+}
+async function issuesOf(reader, since) {
+    const result = [];
+    const seen = new Set();
+    for (let page = 1;; page += 1) {
+        const values = rows(await reader.read(`issues?state=closed&since=${encodeURIComponent(since)}&per_page=100&page=${String(page)}`, [
+            "--jq",
+            'map({number, html_url, closed_at, state, state_reason} + (if has("pull_request") then {pull_request: {}} else {} end))',
+        ]));
+        for (const row of values) {
+            if (Object.hasOwn(row, "pull_request"))
+                continue;
+            const number = identity(row, {
+                repository: reader.repository,
+                kind: "issues",
+            });
+            if (seen.has(number))
+                throw new Error("response");
+            seen.add(number);
+            if (!completedIssue(row))
+                continue;
+            result.push({
+                at: timestamp(row["closed_at"]),
+                value: 1,
+                evidence: { issue: number },
+            });
+        }
+        if (values.length < 100)
+            return result;
+    }
+}
+async function pullsOf(reader, since) {
+    const result = [];
+    const seen = new Set();
+    for (let page = 1;; page += 1) {
+        const values = rows(await reader.read(`pulls?state=closed&sort=updated&direction=desc&per_page=100&page=${String(page)}`));
+        for (const row of values) {
+            const number = identity(row, {
+                repository: reader.repository,
+                kind: "pull",
+            });
+            if (seen.has(number))
+                throw new Error("response");
+            seen.add(number);
+            timestamp(row["updated_at"]);
+            if (row["merged_at"] === null)
+                continue;
+            result.push({
+                at: timestamp(row["merged_at"]),
+                value: 1,
+                evidence: { pullRequest: number },
+            });
+        }
+        if (values.length < 100 ||
+            values.some((row) => Date.parse(String(row["updated_at"])) < Date.parse(since)))
+            return result;
+    }
+}
+async function repositoryReader(input) {
+    const settings = input.settings;
+    if (settings?.repository === undefined)
+        throw new Error("configuration");
+    const command = commandOf(settings.githubCommand);
+    const signal = AbortSignal.timeout(120_000);
+    const origin = await settings.execute({
+        command: ["git", "config", "--local", "--get-all", "remote.origin.url"],
+        directory: settings.repository,
+        signal,
+    });
+    const repository = origin.status === 0 && origin.errorCode === null
+        ? prRepository(origin.stdout)
+        : null;
+    if (repository === null)
+        throw new Error("identity");
+    const directory = settings.repository;
+    return {
+        repository,
+        read: async (endpoint, flags = []) => {
+            const output = await githubRetry({
+                signal,
+                pollMilliseconds: input.retryMilliseconds ?? 30_000,
+                action: async () => {
+                    const output = await settings.execute({
+                        directory,
+                        signal,
+                        command: [
+                            ...command,
+                            "api",
+                            "--method",
+                            "GET",
+                            "--hostname",
+                            repository.host,
+                            `repos/${repository.owner}/${repository.repository}${endpoint === "" ? "" : `/${endpoint}`}`,
+                            ...flags,
+                        ],
+                    });
+                    if (output.status !== 0 || output.errorCode !== null)
+                        throw Object.assign(new Error("github-call-failed"), {
+                            status: Number(/\(HTTP (\d{3})\)/.exec(output.stderr)?.[1]),
+                            detail: output.stderr,
+                        });
+                    return output.stdout;
+                },
+            });
+            const parsed = JSON.parse(output);
+            return parsed;
+        },
+    };
+}
+function source(result) {
+    if (result.status === "fulfilled")
+        return { status: "available" };
+    const reason = result.reason instanceof Error &&
+        result.reason.message === "github-network-failed"
+        ? "github-network-failed"
+        : "read-failed";
+    return { status: "unavailable", reason };
+}
+async function repositoryCreatedAt(reader) {
+    const repository = record(await reader.read(""));
+    const name = repository?.["full_name"];
+    if (typeof name !== "string" ||
+        name.toLowerCase() !==
+            `${reader.repository.owner}/${reader.repository.repository}`)
+        throw new Error("identity");
+    return timestamp(repository?.["created_at"]);
+}
+function completedIssue(row) {
+    if (row["state"] !== "closed" ||
+        !["completed", "not_planned", "duplicate"].includes(String(row["state_reason"])))
+        throw new Error("response");
+    return row["state_reason"] === "completed";
+}

package/dist/src/cli/report.d.ts

@@ -0,0 +1,17 @@
+import { type Fields } from "../protocol.ts";
+import { type ReportCompletion } from "../report.ts";
+import type { WatchPrSettings } from "./watch-pr-settings.ts";
+interface ReportEnvironment {
+    readonly runtimeDirectory: string;
+    readonly workingDirectory: string;
+    readonly watchPr?: WatchPrSettings;
+    readonly terminal: {
+        readonly out: (text: string) => void;
+    };
+}
+export declare function reportCommand(invocation: {
+    readonly since: number;
+    readonly json: boolean;
+}, environment: ReportEnvironment): Promise<number>;
+export declare function reportCompletion(event: Fields): ReportCompletion | null;
+export {};

package/dist/src/cli/report.js

@@ -0,0 +1,192 @@
+import { record } from "../protocol.js";
+import { loopReport, } from "../report.js";
+import { send } from "./client.js";
+import { readReportGithub } from "./report-github.js";
+function reportRecord(value, after) {
+    const event = record(value) ?? {};
+    const sequence = event["sequence"];
+    const at = event["recordedAt"];
+    if (typeof sequence !== "number" ||
+        !Number.isSafeInteger(sequence) ||
+        sequence <= after ||
+        typeof at !== "string" ||
+        !Number.isFinite(Date.parse(at)))
+        throw new Error("invalid-report-cursor");
+    return { event, sequence, at: Date.parse(at) };
+}
+function appendEvents(snapshot, values) {
+    for (const value of values) {
+        const parsed = reportRecord(value, snapshot.after);
+        if (snapshot.latest !== null && parsed.sequence > snapshot.latest)
+            break;
+        snapshot.after = parsed.sequence;
+        if (snapshot.observedSince === null || parsed.at < snapshot.observedSince)
+            snapshot.observedSince = parsed.at;
+        const completion = reportCompletion(parsed.event);
+        if (completion === null)
+            continue;
+        if (snapshot.completions.has(completion.runId))
+            throw new Error("duplicate-report-completion");
+        snapshot.completions.set(completion.runId, completion);
+    }
+}
+async function daemonReport(runtime) {
+    const snapshot = {
+        after: 0,
+        latest: null,
+        observedSince: null,
+        completions: new Map(),
+    };
+    for (;;) {
+        const reply = await send(runtime, {
+            operation: "events",
+            parameters: { after: snapshot.after, limit: 1000 },
+        });
+        if (reply.kind === "error")
+            throw new Error(reply.error.code);
+        const latest = reply.result["latestSequence"];
+        if (typeof latest !== "number" ||
+            !Number.isSafeInteger(latest) ||
+            latest < snapshot.after)
+            throw new Error("invalid-report-snapshot");
+        snapshot.latest ??= latest;
+        const events = reply.result["events"];
+        if (!Array.isArray(events))
+            throw new Error("invalid-report-events");
+        appendEvents(snapshot, events);
+        if (snapshot.after >= snapshot.latest)
+            return {
+                completions: [...snapshot.completions.values()],
+                observedSince: snapshot.observedSince,
+            };
+        if (events.length < 1000)
+            throw new Error("incomplete-report-snapshot");
+    }
+}
+function settledSpending(run) {
+    const condition = run["condition"];
+    const effects = run["effects"];
+    return (["completed", "failed", "cancelled"].includes(String(condition)) &&
+        Array.isArray(effects) &&
+        effects.every((value) => ["completed", "failed", "stopped", "cancelled", "refused"].includes(String(record(value)?.["state"]))));
+}
+async function runCost(runtime, runId) {
+    const reply = await send(runtime, {
+        operation: "status",
+        parameters: { runId },
+    });
+    if (reply.kind === "error")
+        return { runId, turns: null };
+    const run = record(reply.result["run"]);
+    const turns = run?.["workerTurns"];
+    if (run?.["runId"] !== runId ||
+        !Array.isArray(turns) ||
+        !settledSpending(run))
+        return { runId, turns: null };
+    const parsed = turns.map((value) => {
+        const turn = record(value);
+        const operationId = turn?.["operationId"];
+        const costUsd = turn?.["costUsd"];
+        return typeof operationId === "string" &&
+            (costUsd === null ||
+                (typeof costUsd === "number" &&
+                    Number.isFinite(costUsd) &&
+                    costUsd >= 0))
+            ? { operationId, costUsd }
+            : null;
+    });
+    return {
+        runId,
+        turns: parsed.some((turn) => turn === null)
+            ? null
+            : parsed.filter((turn) => turn !== null),
+    };
+}
+function textReport(report) {
+    const lines = [`Loop report ${JSON.stringify(report["window"])}`];
+    for (const [name, value] of Object.entries(record(report["metrics"]) ?? {})) {
+        const metric = record(value) ?? {};
+        lines.push(`${name}: ${metric["status"] === "unavailable" ? "unavailable" : String(metric["value"])}`);
+        const baseline = record(metric["baseline"]) ?? {};
+        lines.push(`  history: ${String(baseline["history"])}; median: ${String(baseline["median"])}; band: ${JSON.stringify(baseline["band"])}${metric["mark"] === "outside" ? "; outside" : ""}`);
+        lines.push(`  comparison value: ${String(metric["comparisonValue"])}`);
+        lines.push(`  evidence: ${JSON.stringify(metric["evidence"])}`);
+        lines.push(`  baseline evidence: ${JSON.stringify(baseline["evidence"])}`);
+    }
+    lines.push(`Run costs (USD): ${JSON.stringify(report["runCosts"])}`);
+    lines.push(`Sources: ${JSON.stringify(report["sources"])}`);
+    lines.push(`Coverage: ${JSON.stringify(report["coverage"])}`);
+    return lines.join("\n") + "\n";
+}
+export async function reportCommand(invocation, environment) {
+    const now = Date.now();
+    const since = new Date(now - (invocation.since + 168) * 3_600_000).toISOString();
+    const settings = environment.watchPr === undefined ? {} : { settings: environment.watchPr };
+    const [daemonRead, githubRead] = await Promise.allSettled([
+        daemonReport(environment.runtimeDirectory),
+        readReportGithub({ since, ...settings }),
+    ]);
+    const daemon = daemonRead.status === "fulfilled"
+        ? daemonRead.value
+        : { completions: null, observedSince: null };
+    const github = githubRead.status === "fulfilled" ? { github: githubRead.value } : {};
+    const costs = [];
+    for (const event of daemon.completions ?? [])
+        if (event.at >= now - (invocation.since + 168) * 3_600_000 &&
+            event.at < now)
+            costs.push(await runCost(environment.runtimeDirectory, event.runId));
+    const calculated = loopReport({
+        since: invocation.since,
+        now,
+        ...daemon,
+        costs,
+        ...github,
+    });
+    const report = {
+        ...calculated,
+        window: {
+            ...calculated.window,
+            start: new Date(calculated.window.start).toISOString(),
+            end: new Date(now).toISOString(),
+        },
+        runCosts: calculated.runCosts.map((cost) => ({
+            ...cost,
+            completedAt: new Date(cost.completedAt).toISOString(),
+        })),
+    };
+    environment.terminal.out(invocation.json ? `${JSON.stringify(report)}\n` : textReport(report));
+    return 0;
+}
+function outcomeOf(event) {
+    if (event["type"] === "run.failed")
+        return "failed";
+    if (event["type"] === "run.cancelled")
+        return "cancelled";
+    if (event["type"] !== "run.completed")
+        return null;
+    const payload = record(event["payload"]) ?? {};
+    if (payload["outcome"] === "handoff_requested" &&
+        payload["ticketStatus"] === "partial")
+        return "partial";
+    const outcome = payload["outcome"];
+    if (outcome === undefined || outcome === "handoff_requested")
+        return "completed";
+    return outcome === "blocked" ? "blocked" : null;
+}
+export function reportCompletion(event) {
+    const terminal = ["run.completed", "run.failed", "run.cancelled"].includes(String(event["type"]));
+    if (!terminal)
+        return null;
+    const outcome = outcomeOf(event);
+    if (outcome === null)
+        throw new Error("invalid-report-event");
+    const runId = event["runId"];
+    const sequence = event["sequence"];
+    const at = event["recordedAt"];
+    if (typeof runId !== "string" ||
+        typeof sequence !== "number" ||
+        typeof at !== "string" ||
+        !Number.isFinite(Date.parse(at)))
+        throw new Error("invalid-report-event");
+    return { runId, sequence, at: Date.parse(at), outcome };
+}

package/dist/src/cli/repository-arguments.d.ts

@@ -0,0 +1,5 @@
+import { type ParseArgsConfig } from "node:util";
+export declare function repositoryArguments(argumentsList: readonly string[], options: NonNullable<ParseArgsConfig["options"]>): {
+    readonly argumentsList: readonly string[];
+    readonly repository: string | undefined;
+} | string;