cloving 1.2.0 → 1.3.0

package/dist/src/cli/main.js

@@ -1,27 +1,27 @@
+import { configCommand } from "./config-command.js";
+import { doctorCommand } from "./doctor.js";
 import { randomUUID } from "node:crypto";
 import packageMetadata from "#package" with { type: "json" };
-import { redactImport } from "../chats/redact-import.js";
-import { emptyCounts } from "../chats/redaction.js";
-import { importChats } from "../chats/import.js";
 import { parseInvocation } from "./arguments.js";
+import { phoneCommand } from "./phone-command.js";
 import { runtimeCommand } from "./commands.js";
 import { clientCommand, runtimeDirectory } from "./runtime-directory.js";
-import { chatsRedactUsage, chatsImportUsage, usage, validateUsage, } from "./usage.js";
+import { commandUsage, configUsage, phoneUsage, usage, validateUsage, } from "./usage.js";
 import { validateWorkflow } from "./validate.js";
 const helpTexts = {
     help: usage,
     version: `${packageMetadata.version}\n`,
     "validate-help": validateUsage,
-    "chats-import-help": chatsImportUsage,
-    "chats-redact-help": chatsRedactUsage,
+    "phone-help": phoneUsage,
+    "doctor-help": String(commandUsage["doctor"]),
+    "config-help": configUsage,
 };
 function helpInvocation(invocation) {
     return Object.hasOwn(helpTexts, invocation.kind);
 }
-export async function main(argumentsList, watchPr) {
+export async function main(argumentsList, context = { repository: undefined }) {
+    const { repository, environment = process.env } = context;
     const invocation = parseInvocation(argumentsList);
-    if (refuseChatPlatform(invocation))
-        return;
     if (helpInvocation(invocation)) {
         process.stdout.write(helpTexts[invocation.kind]);
         return;
@@ -32,31 +32,32 @@ export async function main(argumentsList, watchPr) {
     else if (invocation.kind === "validate") {
         await validationCommand(invocation);
     }
-    else if (invocation.kind === "chats-redact") {
-        await redactionCommand(invocation.importId);
+    else if (invocation.kind === "doctor") {
+        if (context.doctorProbe === undefined)
+            throw new Error("doctor-probe-unavailable");
+        process.exitCode = await doctorCommand({
+            probe: context.doctorProbe,
+            repository,
+            environment,
+            json: invocation.json,
+        });
     }
-    else if (invocation.kind === "chats-import") {
-        const result = await importChats({
-            ...invocation,
-            workingDirectory: process.cwd(),
-            runtimeDirectory: runtimeDirectory(process.env),
+    else if (invocation.kind === "config") {
+        process.exitCode = await configCommand(invocation, repository);
+    }
+    else if (invocation.kind === "phone") {
+        process.exitCode = await phoneCommand(invocation, {
+            runtimeDirectory: runtimeDirectory(process.env, repository),
+            terminal,
         });
-        process.stdout.write(`${JSON.stringify(result)}\n`);
-        process.exitCode = result.code === "import-complete" ? 0 : 1;
     }
     else {
         process.exitCode = await runtimeCommand(invocation, {
-            runtimeDirectory: runtimeDirectory(process.env),
-            ...(process.env["CLOVING_WATCH_ACTIONS"] === undefined
-                ? {}
-                : { watchActions: process.env["CLOVING_WATCH_ACTIONS"] }),
-            ...(watchPr === undefined ? {} : { watchPr }),
-            client: clientCommand(process.env),
+            runtimeDirectory: runtimeDirectory(process.env, repository),
+            ...watchSettings(context.watchPr, environment),
+            client: clientCommand(process.env, repository),
             workingDirectory: process.cwd(),
-            terminal: {
-                out: (text) => process.stdout.write(text),
-                error: (text) => process.stderr.write(text),
-            },
+            terminal,
             identifier: randomUUID,
             interrupted: () => new Promise((settle) => {
                 for (const signal of ["SIGINT", "SIGTERM"])
@@ -67,15 +68,16 @@ export async function main(argumentsList, watchPr) {
         });
     }
 }
-function refuseChatPlatform(invocation) {
-    if (process.platform === "darwin")
-        return false;
-    if (invocation.kind !== "chats-import" && invocation.kind !== "chats-redact")
-        return false;
-    process.stdout.write(`${JSON.stringify({ code: "platform-unsupported" })}\n`);
-    process.stderr.write("platform-unsupported: Chat commands require macOS.\n");
-    process.exitCode = 1;
-    return true;
+const terminal = {
+    out: (text) => process.stdout.write(text),
+    error: (text) => process.stderr.write(text),
+};
+function watchSettings(watchPr, environment) {
+    const watchActions = environment["CLOVING_WATCH_ACTIONS"];
+    return {
+        ...(watchActions === undefined ? {} : { watchActions }),
+        ...(watchPr === undefined ? {} : { watchPr }),
+    };
 }
 function presentUsageError(invocation) {
     if (invocation.json)
@@ -101,27 +103,3 @@ function present(report, format) {
     for (const error of report.errors)
         process.stderr.write(`${error.code}: ${error.file}: ${error.detail}\n`);
 }
-async function redactionCommand(importId) {
-    let privateTexts = [];
-    try {
-        const setting = process.env["CLOVING_PRIVATE_TEXTS"];
-        if (setting !== undefined)
-            privateTexts = JSON.parse(setting);
-        if (!Array.isArray(privateTexts) ||
-            !privateTexts.every((item) => typeof item === "string" && item.trim() !== ""))
-            throw new Error("invalid-settings");
-    }
-    catch {
-        process.stdout.write(`${JSON.stringify({ code: "invalid-settings", importId, recordCount: 0, counts: emptyCounts(), totalCount: 0 })}\n`);
-        process.exitCode = 1;
-        return;
-    }
-    const result = await redactImport({
-        importId,
-        workingDirectory: process.cwd(),
-        runtimeDirectory: runtimeDirectory(process.env),
-        settings: { home: process.env["HOME"] || null, privateTexts },
-    });
-    process.stdout.write(`${JSON.stringify(result)}\n`);
-    process.exitCode = result.code === "redaction-complete" ? 0 : 1;
-}

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

@@ -0,0 +1,14 @@
+export type PhoneCommandName = "status" | "list" | "remove" | "reset";
+export type PhoneInvocation = {
+    readonly kind: "phone-help";
+} | {
+    readonly kind: "phone";
+    readonly command: PhoneCommandName;
+    readonly deviceId: string | null;
+    readonly json: boolean;
+} | {
+    readonly kind: "usage-error";
+    readonly code: string;
+    readonly json: boolean;
+};
+export declare function phoneInvocation(argumentsList: readonly string[]): PhoneInvocation;

package/dist/src/cli/phone-arguments.js

@@ -0,0 +1,37 @@
+const commands = [
+    "status",
+    "list",
+    "remove",
+    "reset",
+];
+function phoneCommandName(name) {
+    return commands.find((command) => command === name);
+}
+function unexpected(tokens, command) {
+    const allowed = command === "remove" ? 1 : 0;
+    const options = tokens.filter((token) => token.startsWith("-"));
+    const subjects = tokens.filter((token) => !token.startsWith("-"));
+    if (options.some((option) => option !== "--json"))
+        return "unexpected-option";
+    if (subjects.length > allowed)
+        return "unexpected-argument";
+    return subjects.length < allowed ? "missing-argument" : undefined;
+}
+export function phoneInvocation(argumentsList) {
+    const json = argumentsList.includes("--json");
+    if (argumentsList.includes("--help") || argumentsList.includes("-h"))
+        return { kind: "phone-help" };
+    const [name, ...rest] = argumentsList;
+    const command = phoneCommandName(name);
+    if (command === undefined)
+        return {
+            kind: "usage-error",
+            code: name === undefined ? "missing-argument" : "unknown-command",
+            json,
+        };
+    const code = unexpected(rest, command);
+    if (code !== undefined)
+        return { kind: "usage-error", code, json };
+    const deviceId = rest.find((token) => !token.startsWith("-")) ?? null;
+    return { kind: "phone", command, deviceId, json };
+}

package/dist/src/cli/phone-client.d.ts

@@ -0,0 +1,2 @@
+import { type Reply, type ServiceRequest } from "../protocol.ts";
+export declare function phoneRequest(runtimeDirectory: string, request: ServiceRequest): Promise<Reply | undefined>;

package/dist/src/cli/phone-client.js

@@ -0,0 +1,32 @@
+import net from "node:net";
+import { join } from "node:path";
+import { socketAddress } from "../broker/socket-address.js";
+import { parseReplyLine, requestLine, } from "../protocol.js";
+const absent = ["ENOENT", "ECONNREFUSED"];
+export function phoneRequest(runtimeDirectory, request) {
+    const address = socketAddress(join(runtimeDirectory, "phone.sock"));
+    if (address.kind === "refused")
+        return Promise.resolve({
+            kind: "error",
+            error: { code: address.reason, detail: address.detail },
+        });
+    return new Promise((settle, reject) => {
+        const socket = net.connect(address.path);
+        let buffered = "";
+        socket.setEncoding("utf8");
+        socket.once("connect", () => socket.write(requestLine(request)));
+        socket.on("data", (data) => {
+            buffered += data;
+        });
+        socket.once("end", () => {
+            const parsed = parseReplyLine(buffered.trim());
+            settle(parsed?.kind === "event" ? undefined : parsed);
+        });
+        socket.once("error", (error) => {
+            if (absent.includes(error.code ?? ""))
+                settle(undefined);
+            else
+                reject(error);
+        });
+    });
+}

package/dist/src/cli/phone-command.d.ts

@@ -0,0 +1,13 @@
+import type { PhoneInvocation } from "./phone-arguments.ts";
+type Invocation = Extract<PhoneInvocation, {
+    readonly kind: "phone";
+}>;
+export interface PhoneContext {
+    readonly runtimeDirectory: string | undefined;
+    readonly terminal: {
+        readonly out: (text: string) => void;
+        readonly error: (text: string) => void;
+    };
+}
+export declare function phoneCommand(invocation: Invocation, context: PhoneContext): Promise<number>;
+export {};

package/dist/src/cli/phone-command.js

@@ -0,0 +1,101 @@
+import { record } from "../protocol.js";
+import { phoneRequest } from "./phone-client.js";
+import { oneLine } from "./render.js";
+function counted(count) {
+    return count === 1 ? "1 phone" : `${String(count)} phones`;
+}
+function listed(state) {
+    const devices = state["devices"];
+    if (!Array.isArray(devices))
+        return [];
+    return devices.flatMap((device) => {
+        const fields = record(device);
+        return fields === undefined ? [] : [fields];
+    });
+}
+function stateText(state) {
+    const registration = state["registered"] === true
+        ? `Registered as ${oneLine(state["daemonId"])} with ${oneLine(state["origin"])}.`
+        : "Not registered.";
+    return `${registration} ${counted(listed(state).length)}.\n`;
+}
+function deviceLine(device) {
+    const removedAt = device["removedAt"];
+    const condition = typeof removedAt === "string" ? `removed ${removedAt}` : device["state"];
+    return `${oneLine(device["deviceId"])}  ${oneLine(device["name"])} (${oneLine(device["platform"])})  ${oneLine(condition)}  paired ${oneLine(device["pairedAt"])}\n`;
+}
+function listText(state) {
+    const devices = listed(state);
+    return devices.length === 0
+        ? "No phones.\n"
+        : devices.map(deviceLine).join("");
+}
+function failed(context, reply) {
+    if (reply.kind === "result")
+        return 0;
+    context.terminal.error(`${oneLine(reply.error.code)}: ${oneLine(reply.error.detail)}\n`);
+    return 1;
+}
+function warned(context, result) {
+    const warning = result["warning"];
+    if (typeof warning === "string")
+        context.terminal.error(`warning: ${oneLine(warning)}\n`);
+}
+const operations = {
+    status: "phone-state",
+    list: "phone-state",
+    remove: "phone-remove",
+    reset: "phone-reset",
+};
+function jsonShown(command, result) {
+    if (command === "list")
+        return { devices: listed(result) };
+    if (command === "status")
+        return { relay: "on", ...result };
+    return result;
+}
+function shown(exchange, result) {
+    const { invocation } = exchange;
+    if (invocation.json)
+        return `${JSON.stringify(jsonShown(invocation.command, result))}\n`;
+    if (invocation.command === "status")
+        return stateText(result);
+    if (invocation.command === "list")
+        return listText(result);
+    if (invocation.command === "remove")
+        return `Removed the phone ${String(invocation.deviceId)}.\n`;
+    return `Removed the registration and ${counted(Number(result["removed"]))}.\n`;
+}
+function relayOff(exchange) {
+    const { invocation, context } = exchange;
+    if (invocation.command !== "status") {
+        context.terminal.error("phone-relay-off: The phone relay is off or not started.\n");
+        return 1;
+    }
+    context.terminal.out(invocation.json
+        ? `${JSON.stringify({ relay: "off" })}\n`
+        : "The phone relay is off or not started.\n");
+    return 0;
+}
+async function exchanged(exchange) {
+    const { invocation, context, runtimeDirectory } = exchange;
+    const reply = await phoneRequest(runtimeDirectory, {
+        operation: operations[invocation.command],
+        parameters: invocation.deviceId === null ? {} : { deviceId: invocation.deviceId },
+    });
+    if (reply === undefined)
+        return relayOff(exchange);
+    if (reply.kind === "error")
+        return failed(context, reply);
+    warned(context, reply.result);
+    context.terminal.out(shown(exchange, reply.result));
+    return 0;
+}
+export async function phoneCommand(invocation, context) {
+    const { runtimeDirectory } = context;
+    if (runtimeDirectory === undefined) {
+        context.terminal.error("repository-unknown: Change to the service repository, use --repository <directory>, or set CLOVING_RUNTIME_DIR.\n");
+        return 1;
+    }
+    return exchanged({ invocation, context, runtimeDirectory });
+}

package/dist/src/cli/probe-command.d.ts

@@ -0,0 +1,36 @@
+import type { Readable } from "node:stream";
+interface ProbeChild {
+    readonly pid?: number | undefined;
+    readonly stdout: Readable;
+    kill(signal: NodeJS.Signals): boolean;
+    once(event: "error", listener: (error: Error) => void): this;
+    once(event: "close", listener: (code: number | null) => void): this;
+}
+interface ProbeEffects {
+    readonly spawn: (input: {
+        readonly executable: string;
+        readonly arguments: string[];
+        readonly options: {
+            readonly env: Readonly<NodeJS.ProcessEnv>;
+            readonly cwd?: string;
+            readonly stdio: ["ignore", "pipe", "ignore"];
+            readonly detached: true;
+        };
+    }) => ProbeChild;
+    readonly kill: (identifier: number, signal: NodeJS.Signals) => boolean;
+}
+export interface ProbeOptions {
+    readonly arguments: readonly string[];
+    readonly env: Readonly<NodeJS.ProcessEnv>;
+    readonly directory?: string;
+    readonly milliseconds?: number;
+    readonly bytes?: number;
+}
+export type ProbeRunner = (executable: string, options: ProbeOptions) => Promise<ProbeOutput>;
+export interface ProbeOutput {
+    readonly exitCode?: number | null;
+    readonly stdout: string;
+    readonly reason: string | null;
+}
+export declare function createProbeRunner(effects: ProbeEffects): ProbeRunner;
+export {};

package/dist/src/cli/probe-command.js

@@ -0,0 +1,59 @@
+function killProbe(child, effects) {
+    if (child.pid === undefined)
+        return;
+    try {
+        effects.kill(-child.pid, "SIGKILL");
+    }
+    catch {
+        child.kill("SIGKILL");
+    }
+}
+export function createProbeRunner(effects) {
+    return (executable, options) => executeProbe({ executable, options, effects });
+}
+function executeProbe(input) {
+    const { executable, options, effects } = input;
+    return new Promise((complete) => {
+        const child = effects.spawn({
+            executable,
+            arguments: [...options.arguments],
+            options: {
+                env: options.env,
+                ...(options.directory === undefined ? {} : { cwd: options.directory }),
+                stdio: ["ignore", "pipe", "ignore"],
+                detached: true,
+            },
+        });
+        const chunks = [];
+        let bytes = 0;
+        let reason = null;
+        const stop = (failure) => {
+            if (reason !== null)
+                return;
+            reason = failure;
+            killProbe(child, effects);
+            child.stdout.destroy();
+        };
+        child.stdout.on("data", (chunk) => {
+            bytes += chunk.length;
+            if (bytes > (options.bytes ?? 65536))
+                stop("probe-output-limit");
+            else
+                chunks.push(chunk);
+        });
+        const timer = setTimeout(() => {
+            stop("probe-timeout");
+        }, options.milliseconds ?? 10000);
+        child.once("error", () => {
+            reason ??= "probe-start";
+        });
+        child.once("close", (code) => {
+            clearTimeout(timer);
+            complete({
+                exitCode: code,
+                stdout: Buffer.concat(chunks).toString("utf8"),
+                reason: reason ?? (code === 0 ? null : "probe-exit"),
+            });
+        });
+    });
+}

package/dist/src/cli/project-settings.d.ts

@@ -0,0 +1,4 @@
+import { resolveSettings } from "../project-settings.ts";
+export declare function privateSettingsPath(environment: Readonly<NodeJS.ProcessEnv>, repository: string): string;
+export declare function projectSettings(environment: Readonly<NodeJS.ProcessEnv>, repository: string): ReturnType<typeof resolveSettings>;
+export declare function settingsEnvironment(environment: Readonly<NodeJS.ProcessEnv>, repository: string): Readonly<NodeJS.ProcessEnv>;

package/dist/src/cli/project-settings.js

@@ -0,0 +1,33 @@
+import { readFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { configurationRoot, resolveSettings } from "../project-settings.js";
+import { repositoryRuntimeName } from "./runtime-directory.js";
+export function privateSettingsPath(environment, repository) {
+    return join(configurationRoot(environment, homedir()), "cloving/projects", `${repositoryRuntimeName(repository)}.json`);
+}
+function read(file) {
+    try {
+        return readFileSync(file.path, "utf8");
+    }
+    catch (error) {
+        if (error instanceof Error && "code" in error && error.code === "ENOENT")
+            return undefined;
+        throw new Error(`unreadable-config-file: ${file.scope}`, { cause: error });
+    }
+}
+export function projectSettings(environment, repository) {
+    return resolveSettings(environment, {
+        project: read({
+            path: join(repository, ".cloving/config.json"),
+            scope: "project",
+        }),
+        private: read({
+            path: privateSettingsPath(environment, repository),
+            scope: "private",
+        }),
+    });
+}
+export function settingsEnvironment(environment, repository) {
+    return projectSettings(environment, repository).environment;
+}

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

@@ -1,8 +1,9 @@
 import { type Fields } from "../protocol.ts";
+export declare function oneLine(value: unknown): string;
 export declare function errorText(error: Fields): string;
 export declare function runOverview(result: Fields): Fields;
 export declare function queueLines(value: unknown): readonly string[];
-export declare function statusJson(result: Fields): Fields;
+export { statusJson } from "./usage-render.ts";
 export declare function runStatus(result: Fields): readonly string[];
 export declare function decisionLines(decision: unknown): readonly string[];
 export declare function decisionList(result: Fields): readonly string[];

package/dist/src/cli/render.js

@@ -1,6 +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);
 }
@@ -20,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")
@@ -59,15 +63,26 @@ function admitted(result) {
 }
 function runLine(run) {
     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, ...chainLines(run).map((link) => `    ${link}`)].join("\n");
+    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"]));
 }
@@ -154,38 +169,31 @@ function outcomeLines(value) {
             : []),
     ];
 }
+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);
@@ -204,6 +212,7 @@ export function runStatus(result) {
         `Title: ${visible(part(run, "title") ?? "none")}`,
         `State: ${show(part(run, "state"))}`,
         ...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"))}`,
@@ -216,12 +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 {};