cloving 1.2.0 → 1.3.0

package/dist/src/broker/actor/authority-receipts.js

@@ -1,5 +1,6 @@
 import { integer, text } from "../../storage/domain-rows.js";
 import { intentKind } from "../authority-restore.js";
+import { commandLimits } from "../../command-settings.js";
 export const unserializable = {
     kind: "rejected",
     reason: "invalid-command",
@@ -16,7 +17,16 @@ export const tooLarge = {
     detail: `A request has at most ${String(maximumRequestBytes)} bytes.`,
 };
 export function oversized(request) {
-    return Buffer.byteLength(JSON.stringify(request)) > maximumRequestBytes;
+    const command = request["command"];
+    const report = typeof command === "object" &&
+        command !== null &&
+        !Array.isArray(command) &&
+        command["kind"] === "report-effect" &&
+        command["worker"] === "command";
+    const limit = report
+        ? maximumRequestBytes + commandLimits.stdoutBytes * 6
+        : maximumRequestBytes;
+    return Buffer.byteLength(JSON.stringify(request)) > limit;
 }
 export function failed(error) {
     const name = String(Reflect.get(Object(error), "name"));

package/dist/src/broker/actor/authority-session.js

@@ -1,5 +1,5 @@
 import { eligibleIntents, } from "../../authority/reducer.js";
-import { loadProjections, } from "../../storage/decision-snapshots.js";
+import { loadOperationSnapshot, loadProjections, } from "../../storage/decision-snapshots.js";
 import { loadEvents } from "../../storage/domain-rows.js";
 import { pinnedResumption } from "../authority-admission.js";
 import { currentState, intentKind, storedDefinitions, storedEvents, } from "../authority-restore.js";
@@ -40,7 +40,7 @@ export function authoritySession(parts) {
             return storedEvents(await parts.reader.connection(loadEvents));
         },
         eligibleIntents: async () => eligible(await projected(session)),
-        operations: async () => operationRecords(await projected(session)),
+        operations: async () => operationRecords(await read(loadOperationSnapshot)),
         resumePinned: async (runId, manifest) => {
             const snapshot = await projected(session);
             return pinnedResumption(currentState(snapshot), {

package/dist/src/broker/actor/authority-settings.js

@@ -1,5 +1,6 @@
 import { recoveryBound } from "../../authority/commands.js";
 import { lineLogger } from "./authority-logger.js";
+import { commandLimits } from "../../command-settings.js";
 export const authorityTiming = {
     leaseMilliseconds: 2_000,
     renewalMilliseconds: 500,
@@ -50,6 +51,9 @@ export function librarySettings(timing, log) {
     return {
         tableNamePrefix: "solid_",
         maxAttempts: 1,
+        maxActivationDurationMilliseconds: 50,
+        maxPayloadBytes: 900_000 + commandLimits.stdoutBytes * 6,
+        maxResultBytes: 900_000 + commandLimits.stdoutBytes * 6,
         logger: lineLogger(log ?? standardError),
         leaseDurationMilliseconds: timing.leaseMilliseconds,
         leaseRenewalIntervalMilliseconds: timing.renewalMilliseconds,

package/dist/src/broker/actor/delivery-intents.d.ts

@@ -18,6 +18,7 @@ export interface DeliveryIntent extends EffectIntent, Partial<DeliveryDecision>,
     readonly workflow: string;
     readonly inputDigest: string;
     readonly purpose: Purpose;
+    readonly commandDeadline?: string;
 }
 export type ProtectedIntent = DeliveryIntent & EffectArguments;
 export type Undigested = Omit<DeliveryIntent, "inputDigest" | "purpose">;
@@ -54,7 +55,7 @@ export interface Delivery {
     readonly retry?: Delivery["reconcile"];
     readonly stop?: (intent: DeliveryIntent, signal: AbortSignal) => Promise<AdapterOutcome>;
 }
-export type AvailableManifest = (pinned: ExecutionManifest) => ExecutionManifest | undefined;
+export type AvailableManifest = (pinned: ExecutionManifest) => ExecutionManifest | undefined | Promise<ExecutionManifest | undefined>;
 export declare function intentDigest(intent: Undigested): string;
 export declare function deliveryIntent(intent: Undigested): DeliveryIntent;
 export declare function protectedIntent(state: AuthorityState, attempt: {

package/dist/src/broker/actor/delivery-intents.js

@@ -1,7 +1,7 @@
 import { createHash } from "node:crypto";
-import { continues, isSettled } from "../../authority/gates.js";
+import { delivers, isSettled } from "../../authority/gates.js";
 import { eligibleIntents, } from "../../authority/reducer.js";
-import { gateContinuation } from "../../authority/reduction.js";
+import { gateDelivery } from "../../authority/reduction.js";
 export function intentDigest(intent) {
     const base = [intent.kind, intent.runId, intent.operationId, intent.workflow];
     const bound = intent.gateId === undefined
@@ -37,7 +37,7 @@ export function protectedIntent(state, attempt) {
     })));
 }
 export function gateDecision(gate) {
-    if (gate === undefined || gate.kind === "untyped" || !continues(gate))
+    if (gate === undefined || gate.kind === "untyped" || !delivers(gate))
         return null;
     return {
         gateId: gate.gateId,
@@ -51,7 +51,7 @@ function workflowOf(state, runId) {
 function decisionOf(state, intent) {
     return gateDecision(Object.values(state.gates).find((gate) => gate.runId === intent.runId &&
         isSettled(gate) &&
-        gateContinuation(gate).operationId === intent.operationId));
+        gateDelivery(gate).operationId === intent.operationId));
 }
 export function observingIntent(state, attempt) {
     const { intent, purpose } = attempt;

package/dist/src/broker/actor/effect-delivery.js

@@ -4,6 +4,7 @@ import { budgetRow } from "../../storage/effect-rows.js";
 import { effectInputDigest, storedBudget } from "../effect-restore.js";
 import { settlement } from "./adapter-outcomes.js";
 import { pinned } from "./pin-check.js";
+import { commandLimits } from "../../command-settings.js";
 const absent = {
     attempt: undefined,
     released: false,
@@ -51,7 +52,9 @@ async function called(parts, call) {
     const adapterCall = parts.delivery[name]?.bind(parts.delivery);
     if (adapterCall === undefined)
         return { kind: "unknown", reason: "stop-not-supported" };
-    return settlement(await parts.calls.call(intent.operationId, (signal) => adapterCall(intent, signal)), parts.effects.resultBytes);
+    return settlement(await parts.calls.call(intent.operationId, (signal) => adapterCall(intent, signal)), intent.capability === "command"
+        ? commandLimits.resultBytes
+        : parts.effects.resultBytes);
 }
 const confirmations = ["stopped", "completed", "failed"];
 async function stopRequested(parts, intent) {

package/dist/src/broker/actor/effect-queries.d.ts

@@ -16,6 +16,7 @@ export interface EffectQueries {
     readonly dueLeases: (instant: string) => Promise<readonly DueLease[]>;
     readonly stops: (runId: string) => Promise<readonly string[]>;
     readonly closure: (runId: string) => Promise<RunClosure>;
+    readonly settledAt: (runId: string) => Promise<number | null>;
 }
 export interface DueLease {
     readonly runId: string;

package/dist/src/broker/actor/effect-queries.js

@@ -3,6 +3,12 @@ import { integer, optionalInteger, optionalText, text, } from "../../storage/dom
 import { budgetColumns, budgetRow, evidenceColumns, evidenceRow, operationColumns, operationRow, } from "../../storage/effect-rows.js";
 import { storedBudget } from "../effect-restore.js";
 import { stopping } from "./stop-turn.js";
+async function settledAt(connection, runId) {
+    const rows = await connection.all("SELECT recorded_at FROM events WHERE sequence IN (SELECT settled_sequence FROM operations WHERE run_id = ? UNION ALL SELECT min(e.sequence) FROM events e JOIN stopped_operations s ON s.run_id = e.run_id AND s.operation_id = json_extract(e.payload, '$.operationId') WHERE e.run_id = ? AND (EXISTS (SELECT 1 FROM deliveries d WHERE d.operation_id = s.operation_id AND d.outcome = 'sent') OR (SELECT d.outcome FROM deliveries d WHERE d.operation_id = s.operation_id ORDER BY d.staged_sequence DESC, d.rowid DESC LIMIT 1) NOT IN ('withheld', 'blocked', 'absent')) AND ((e.type = 'run.observed' AND json_extract(e.payload, '$.condition') = 'stopped') OR (e.type = 'operation.reconciled' AND json_extract(e.payload, '$.outcome') = 'stopped')) GROUP BY s.operation_id)", [runId, runId]);
+    if (rows.length === 0)
+        return null;
+    return rows.reduce((latest, row) => Math.max(latest, Date.parse(text(row, "recorded_at"))), -Infinity);
+}
 async function storedClosure(connection, scope) {
     const { subjects, cancelledSequence } = await stopping(connection, scope.runId);
     return runClosure(subjects, {
@@ -70,6 +76,7 @@ export function effectQueries(read, settings) {
     return {
         stops: (runId) => read((connection) => stops(connection, runId)),
         closure: (runId) => read((connection) => storedClosure(connection, { runId, stopLimit: settings.stopLimit })),
+        settledAt: (runId) => read((connection) => settledAt(connection, runId)),
         budget: (runId) => read((connection) => budget(connection, runId)),
         dueLeases: (instant) => read((connection) => dueLeases(connection, instant)),
         operation: (operationId) => read((connection) => operation(connection, operationId)),

package/dist/src/broker/actor/pin-check.js

@@ -7,6 +7,6 @@ export async function pinned(connection, check) {
     const stored = readExecutionManifest(JSON.parse(text(await connection.get("SELECT manifest FROM definitions WHERE pin = ?", [
         workflow,
     ]), "manifest")));
-    const current = available(stored);
+    const current = await available(stored);
     return (current !== undefined && resumePinned(stored, current).kind === "admitted");
 }

package/dist/src/broker/actor/stop-plan.js

@@ -15,7 +15,7 @@ function present(state, planning) {
         stopped: subject.stopped || state.effects.stops[subject.operationId] !== undefined,
     };
 }
-const kinds = ["start-run", "continue-run"];
+const kinds = ["start-run", "continue-run", "resume-hook"];
 function intentOf(state, attempt) {
     const { runId, operationId, purpose } = attempt;
     const kind = kinds.find((candidate) => candidate === attempt.kind);

package/dist/src/broker/actor/turn-state.js

@@ -76,7 +76,7 @@ export async function adoptionTurn(connection) {
     return latest;
 }
 export async function recoverableIntents(connection) {
-    const rows = await connection.all("SELECT o.operation_id, o.kind, o.run_id, r.workflow FROM outbox o JOIN runs r ON r.run_id = o.run_id WHERE o.released_sequence IS NULL AND NOT EXISTS (SELECT 1 FROM deliveries d WHERE d.operation_id = o.operation_id AND d.outcome IS NULL) AND ((o.kind = 'start-run' AND r.status = 'queued') OR (o.kind = 'continue-run' AND r.status = 'running') OR (o.kind = 'protected-effect' AND r.status = 'running' AND EXISTS (SELECT 1 FROM operations p WHERE p.operation_id = o.operation_id AND p.status = 'dispatch-pending'))) ORDER BY o.created_sequence, o.rowid LIMIT ?", [recoveryBatch]);
+    const rows = await connection.all("SELECT o.operation_id, o.kind, o.run_id, r.workflow FROM outbox o JOIN runs r ON r.run_id = o.run_id WHERE o.released_sequence IS NULL AND NOT EXISTS (SELECT 1 FROM deliveries d WHERE d.operation_id = o.operation_id AND d.outcome IS NULL) AND ((o.kind = 'start-run' AND r.status = 'queued') OR (o.kind IN ('continue-run', 'resume-hook') AND r.status = 'running') OR (o.kind = 'protected-effect' AND r.status = 'running' AND EXISTS (SELECT 1 FROM operations p WHERE p.operation_id = o.operation_id AND p.status = 'dispatch-pending'))) ORDER BY o.created_sequence, o.rowid LIMIT ?", [recoveryBatch]);
     const intents = [];
     for (const row of rows) {
         const intent = {

package/dist/src/broker/authority-admission.js

@@ -33,15 +33,15 @@ const resumption = (command, context) => {
         ? resumed
         : admissible;
 };
-const effectRequest = (command, context) => {
-    const computed = effectInputDigest({
-        capability: String(command.capability),
-        method: String(command.method),
-        target: String(command.target),
-        payload: String(command.payload),
-    });
-    if (computed !== command.inputDigest)
-        return { kind: "rejected", reason: "input-digest-mismatch" };
+const commandEffect = (command, context) => {
+    const pin = context.state.runs[command.runId]?.workflow ?? "";
+    const names = context.definitions.get(pin)?.commands ?? [];
+    const method = String(command.method);
+    if (!method.startsWith("run:") || !names.includes(method.slice(4)))
+        return { kind: "rejected", reason: "command-not-declared" };
+    return unpinned(command, context);
+};
+const handoffEffect = (command, context) => {
     if (command.capability !== "handoff")
         return unpinned(command, context);
     const pin = context.state.runs[command.runId]?.workflow ?? "";
@@ -52,6 +52,19 @@ const effectRequest = (command, context) => {
         return { kind: "rejected", reason: "invalid-handoff-request" };
     return unpinned(command, context);
 };
+const effectRequest = (command, context) => {
+    const computed = effectInputDigest({
+        capability: String(command.capability),
+        method: String(command.method),
+        target: String(command.target),
+        payload: String(command.payload),
+    });
+    if (computed !== command.inputDigest)
+        return { kind: "rejected", reason: "input-digest-mismatch" };
+    return command.capability === "command"
+        ? commandEffect(command, context)
+        : handoffEffect(command, context);
+};
 const rules = {
     "request-effect": effectRequest,
     "admit-run": admission,

package/dist/src/broker/authority-restore.js

@@ -122,6 +122,7 @@ export function projectedState(snapshot) {
 const intentKinds = [
     "start-run",
     "continue-run",
+    "resume-hook",
     "protected-effect",
 ];
 export function intentKind(value) {

package/dist/src/broker/decision-restore.js

@@ -1,8 +1,8 @@
 import { createHash } from "node:crypto";
-import { continues, gateKey } from "../authority/gates.js";
-import { gateContinuation } from "../authority/reduction.js";
+import { delivers, gateKey } from "../authority/gates.js";
+import { gateDelivery } from "../authority/reduction.js";
 const kinds = ["question", "approval", "untyped"];
-const waits = ["registered", "pending"];
+const waits = ["registered", "pending", "hook"];
 export function documentDigest(body) {
     return `sha256:${createHash("sha256").update(body).digest("hex")}`;
 }
@@ -22,7 +22,7 @@ export function gateRecord(gate) {
         answer: gate.outcome?.answer ?? null,
         decidedSequence: gate.outcome?.sequence ?? null,
         openedSequence: gate.openedSequence,
-        continuation: continues(gate) ? gateContinuation(gate).operationId : null,
+        continuation: delivers(gate) ? gateDelivery(gate).operationId : null,
     };
 }
 const unobserved = {

package/dist/src/broker/socket-address.d.ts

@@ -6,4 +6,6 @@ export type SocketAddress = {
     readonly reason: "runtime-path-too-long";
     readonly detail: string;
 };
-export declare function socketAddress(path: string): SocketAddress;
+export declare function socketAddress(path: string, options?: {
+    readonly directory: string;
+}): SocketAddress;

package/dist/src/broker/socket-address.js

@@ -1,7 +1,7 @@
 import { relative } from "node:path";
 const maximumBytes = 103;
-export function socketAddress(path) {
-    const [shortest] = [path, relative(process.cwd(), path)]
+export function socketAddress(path, options = { directory: process.cwd() }) {
+    const [shortest] = [path, relative(options.directory, path)]
         .filter((candidate) => candidate.length > 0)
         .sort((left, right) => Buffer.byteLength(left) - Buffer.byteLength(right));
     if (shortest === undefined || Buffer.byteLength(shortest) > maximumBytes)

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

@@ -1,23 +1,21 @@
+import { type ConfigInvocation } from "./config-arguments.ts";
+import { type PhoneInvocation } from "./phone-arguments.ts";
 import { type RuntimeInvocation } from "./runtime-arguments.ts";
 export type Invocation = {
+    readonly repository?: string;
+} & (PhoneInvocation | ConfigInvocation | {
+    readonly kind: "config-help";
+} | {
     readonly kind: "help";
 } | {
     readonly kind: "version";
 } | {
-    readonly kind: "validate-help";
-} | {
-    readonly kind: "chats-redact-help";
+    readonly kind: "doctor-help";
 } | {
-    readonly kind: "chats-redact";
-    readonly importId: string;
-} | {
-    readonly kind: "chats-import-help";
+    readonly kind: "doctor";
+    readonly json: boolean;
 } | {
-    readonly kind: "chats-import";
-    readonly paths: readonly string[];
-    readonly roots?: readonly string[];
-    readonly excludeProjects?: readonly string[];
-    readonly previousImportId?: string;
+    readonly kind: "validate-help";
 } | {
     readonly kind: "validate";
     readonly manifest: string;
@@ -27,5 +25,5 @@ export type Invocation = {
     readonly kind: "usage-error";
     readonly code: string;
     readonly json: boolean;
-};
+});
 export declare function parseInvocation(given: readonly string[]): Invocation;

package/dist/src/cli/arguments.js

@@ -1,4 +1,7 @@
 import { parseArgs } from "node:util";
+import { configInvocation } from "./config-arguments.js";
+import { repositoryArguments } from "./repository-arguments.js";
+import { phoneInvocation } from "./phone-arguments.js";
 import { isRuntimeCommand, runtimeInvocation, } from "./runtime-arguments.js";
 const errorCodes = {
     ERR_PARSE_ARGS_UNKNOWN_OPTION: "unknown-option",
@@ -21,6 +24,8 @@ const options = {
     limit: { type: "string" },
     after: { type: "string" },
     follow: { type: "boolean" },
+    since: { type: "string" },
+    repository: { type: "string" },
 };
 const textOptions = ["--prompt", "--text"];
 function knownFlag(token) {
@@ -48,10 +53,27 @@ function textValues(argumentsList) {
     return option === undefined ? joined : [...joined, option];
 }
 export function parseInvocation(given) {
-    if (given[0] === "chats" && given[1] === "import")
-        return chatsImport(given.slice(2));
-    if (given[0] === "chats" && given[1] === "redact")
-        return chatsRedact(given.slice(2));
+    const selected = repositoryArguments(given, options);
+    if (typeof selected === "string")
+        return {
+            kind: "usage-error",
+            code: selected,
+            json: given.includes("--json"),
+        };
+    const invocation = selectedInvocation(selected.argumentsList);
+    return selected.repository === undefined
+        ? invocation
+        : { ...invocation, repository: selected.repository };
+}
+function selectedInvocation(given) {
+    if (given[0] === "config") {
+        const outcome = configInvocation(given.slice(1));
+        return typeof outcome === "string"
+            ? { kind: "usage-error", code: outcome, json: given.includes("--json") }
+            : outcome;
+    }
+    if (given[0] === "phone")
+        return phoneInvocation(given.slice(1));
     const argumentsList = textValues(given);
     const json = given.includes("--json");
     const parsed = parsedArguments(argumentsList);
@@ -61,6 +83,8 @@ export function parseInvocation(given) {
     const [command, ...remaining] = positionals;
     if (command === undefined)
         return topLevel(values);
+    if (command === "doctor")
+        return doctorInvocation(values, remaining);
     if (command === "workflows" && remaining[0] === "validate")
         return validation(values, remaining.slice(1));
     const outcome = runtimeInvocation({
@@ -72,109 +96,13 @@ export function parseInvocation(given) {
         return { kind: "usage-error", code: outcome, json };
     return outcome;
 }
-function chatsRedact(argumentsList) {
-    if (argumentsList.length === 1 &&
-        ["--help", "-h"].includes(String(argumentsList[0])))
-        return { kind: "chats-redact-help" };
-    const importId = argumentsList[0];
-    if (argumentsList.length !== 1 ||
-        importId === undefined ||
-        !/^[a-f\d]{8}-[a-f\d]{4}-4[a-f\d]{3}-[89ab][a-f\d]{3}-[a-f\d]{12}$/.test(importId))
-        return { kind: "usage-error", code: "invalid-import-id", json: false };
-    return { kind: "chats-redact", importId };
-}
-function chatsImport(argumentsList) {
-    const error = (code) => ({
-        kind: "usage-error",
-        code,
-        json: false,
-    });
-    if (argumentsList.length === 1 &&
-        ["--help", "-h"].includes(String(argumentsList[0])))
-        return { kind: "chats-import-help" };
-    const state = {
-        paths: [],
-        roots: [],
-        excludeProjects: [],
-        literal: false,
-        option: undefined,
-        previousImportId: undefined,
-    };
-    for (const argument of argumentsList) {
-        const failure = importArgument(state, argument);
-        if (failure !== undefined)
-            return error(failure);
-    }
-    if (state.option !== undefined)
-        return error("missing-value");
-    if (state.excludeProjects.length > 0 && state.roots.length === 0)
-        return error("roots-required");
-    if (state.paths.length + state.roots.length === 0)
-        return error("missing-argument");
-    return importInvocation(state);
-}
-function importInvocation(state) {
-    const previous = state.previousImportId === undefined
-        ? {}
-        : { previousImportId: state.previousImportId };
-    return state.roots.length === 0
-        ? { kind: "chats-import", paths: state.paths, ...previous }
-        : {
-            kind: "chats-import",
-            paths: state.paths,
-            ...previous,
-            roots: state.roots,
-            excludeProjects: state.excludeProjects,
-        };
-}
-function importArgument(state, argument) {
-    if (state.option !== undefined)
-        return importValue(state, argument);
-    if (argument === "")
-        return "missing-argument";
-    if (state.literal) {
-        state.paths.push(argument);
-        return;
-    }
-    if (argument === "--previous-import" && state.previousImportId !== undefined)
-        return "repeated-previous-import";
-    if (["--root", "--exclude-project", "--previous-import"].includes(argument)) {
-        state.option = argument;
-        return;
-    }
-    if (argument === "--") {
-        state.literal = true;
-        return;
-    }
-    if (argument.startsWith("-"))
-        return "unexpected-option";
-    state.paths.push(argument);
-    return;
-}
-function importValue(state, argument) {
-    if (argument === "" || argument.startsWith("-"))
-        return "missing-value";
-    const option = state.option;
-    state.option = undefined;
-    if (option === "--root") {
-        state.roots.push(argument);
-        return;
-    }
-    if (option === "--exclude-project" && !validProjectName(argument))
-        return "invalid-exclusion";
-    if (option === "--exclude-project") {
-        state.excludeProjects.push(argument);
-        return;
-    }
-    if (!/^[a-f\d]{8}-[a-f\d]{4}-4[a-f\d]{3}-[89ab][a-f\d]{3}-[a-f\d]{12}$/.test(argument))
-        return "invalid-import-id";
-    state.previousImportId = argument;
-    return;
-}
-function validProjectName(name) {
-    return (name !== "." &&
-        name !== ".." &&
-        !["/", "\\", "\0", "*", "?", "[", "]"].some((character) => name.includes(character)));
+function doctorInvocation(values, remaining) {
+    const json = values.json === true;
+    if (unexpected(values, ["help", "json"]))
+        return { kind: "usage-error", code: "unexpected-option", json };
+    if (remaining.length > 0)
+        return { kind: "usage-error", code: "unexpected-argument", json };
+    return values.help ? { kind: "doctor-help" } : { kind: "doctor", json };
 }
 function parsedArguments(argumentsList) {
     try {
@@ -206,6 +134,8 @@ function knownCommand(positionals) {
         return true;
     if (command === "workflows")
         return subcommand === "validate";
+    if (command === "doctor")
+        return true;
     return isRuntimeCommand(command);
 }
 function givenOptions(tokens) {

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

@@ -0,0 +1,7 @@
+import type { CommandEffect } from "../command-settings.ts";
+import { type Shown } from "./watch-element.ts";
+export declare function shownCommands(value: unknown): readonly CommandEffect[];
+export declare function commandText(effect: CommandEffect): string;
+export declare function Commands(props: {
+    readonly effects: readonly CommandEffect[];
+}): Shown;

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

@@ -0,0 +1,39 @@
+import { record } from "../protocol.js";
+import { element } from "./watch-element.js";
+export function shownCommands(value) {
+    if (!Array.isArray(value))
+        return [];
+    return value.flatMap((entry) => {
+        const fields = record(entry);
+        if (typeof fields?.["operationId"] !== "string" ||
+            typeof fields["name"] !== "string" ||
+            typeof fields["state"] !== "string")
+            return [];
+        return [
+            {
+                operationId: fields["operationId"],
+                name: fields["name"],
+                state: fields["state"],
+                exitCode: typeof fields["exitCode"] === "number" ? fields["exitCode"] : null,
+                durationMilliseconds: typeof fields["durationMilliseconds"] === "number"
+                    ? fields["durationMilliseconds"]
+                    : null,
+            },
+        ];
+    });
+}
+export function commandText(effect) {
+    const duration = effect.durationMilliseconds === null
+        ? "duration unknown"
+        : `${String(effect.durationMilliseconds)} ms`;
+    return `Command ${effect.name} · ${effect.state} · exit ${effect.exitCode === null ? "unknown" : String(effect.exitCode)} · ${duration}`;
+}
+export function Commands(props) {
+    return props.effects.map((effect) => element("section", {
+        class: "command-effect code-window",
+        children: element("h3", {
+            class: "code-head",
+            children: commandText(effect),
+        }),
+    }));
+}

package/dist/src/cli/commands.js

@@ -1,3 +1,5 @@
+import { reportCommand } from "./report.js";
+import { withCiReruns } from "./github-ci-progress.js";
 import { readFile } from "node:fs/promises";
 import { resolve } from "node:path";
 import { record, } from "../protocol.js";
@@ -45,8 +47,11 @@ function presented(environment, outcome) {
     return 0;
 }
 async function requested(environment, exchange) {
+    const reply = await send(environment.runtimeDirectory, exchange.request);
     return presented(environment, {
-        reply: await send(environment.runtimeDirectory, exchange.request),
+        reply: exchange.request.operation === "status"
+            ? await withCiReruns(environment.runtimeDirectory, reply)
+            : reply,
         format: exchange.format,
     });
 }
@@ -138,7 +143,7 @@ async function status(environment, invocation) {
     if (!json && runId === null)
         await summarized(environment);
     if (!json && runId === null && limit === null && after === null) {
-        const reply = await listRuns(environment.runtimeDirectory);
+        const reply = await withCiReruns(environment.runtimeDirectory, await listRuns(environment.runtimeDirectory));
         return presented(environment, {
             format: { json },
             reply: reply.kind === "result"
@@ -227,14 +232,16 @@ export function runtimeCommand(invocation, environment) {
     if (runtimeDirectory === undefined)
         return Promise.resolve(failed(environment, {
             error: {
-                code: "runtime-directory-unknown",
-                detail: "No runtime directory is known. Set CLOVING_RUNTIME_DIR to the runtime directory of the service.",
+                code: "repository-unknown",
+                detail: "Change to the service repository, use --repository <directory>, or set CLOVING_RUNTIME_DIR.",
             },
             format: { json: invocation.json },
         }));
     return located(invocation, { ...environment, runtimeDirectory });
 }
 function located(invocation, environment) {
+    if (invocation.kind === "report")
+        return reportCommand(invocation, environment);
     if (invocation.kind === "run")
         return run(environment, invocation);
     if (invocation.kind === "status")

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

@@ -0,0 +1,11 @@
+export interface ConfigInvocation {
+    readonly kind: "config";
+    readonly action: "list" | "get" | "set" | "unset";
+    readonly field?: string;
+    readonly value?: string;
+    readonly private: boolean;
+    readonly json: boolean;
+}
+export declare function configInvocation(argumentsList: readonly string[]): ConfigInvocation | {
+    readonly kind: "config-help";
+} | string;