cloving 1.2.0 → 1.4.0

package/dist/src/cli/watch-phone-view.js

@@ -0,0 +1,113 @@
+import { component, element } from "./watch-element.js";
+export function timeLeft(expiresAt, now) {
+    const seconds = Math.max(0, Math.ceil((Date.parse(expiresAt) - Date.parse(now)) / 1000));
+    return `${String(Math.floor(seconds / 60))}:${String(seconds % 60).padStart(2, "0")} left`;
+}
+export function refusalText(code) {
+    const texts = {
+        "pairing-mac-invalid": "The phone sent a request that does not agree with the QR code.",
+        "pairing-key-invalid": "The phone sent a key that is not valid.",
+        "pairing-request-invalid": "The phone sent a request that is not valid.",
+        "pairing-device-revoked": "This phone was removed. Connect it again as a new phone.",
+        "pairing-expired": "The connection request expired. Click Connect a phone again.",
+        "pairing-check-invalid": "The phone did not confirm the connection. Remove it and connect again.",
+    };
+    return texts[code] ?? `The connection did not work (${code}).`;
+}
+export function PhoneCode(props) {
+    const { size, path } = props.picture;
+    return element("svg", {
+        xmlns: "http://www.w3.org/2000/svg",
+        class: "phone-qr",
+        viewBox: `0 0 ${String(size)} ${String(size)}`,
+        role: "img",
+        "aria-label": "Pairing QR code",
+        "shape-rendering": "crispEdges",
+        children: [
+            element("rect", { width: size, height: size, fill: "#ffffff" }),
+            element("path", { d: path, fill: "#000000" }),
+        ],
+    });
+}
+export function phoneButton(label, onClick) {
+    return element("button", { type: "button", onClick, children: label });
+}
+export function PhoneAsk(props) {
+    const { phone } = props;
+    const request = phone.request;
+    if (request === null)
+        return null;
+    if (phone.stage === "checking")
+        return element("p", { children: `Checking ${request.name}` });
+    return element("div", {
+        class: "phone-ask",
+        children: [
+            element("strong", {
+                children: `Connect "${request.name}" (${request.platform})? Code ${request.code}`,
+            }),
+            phoneButton("Accept", phone.onAccept),
+            phoneButton("Deny", phone.onDeny),
+        ],
+    });
+}
+export function PhoneList(props) {
+    const { phone } = props;
+    if (phone.devices.length === 0)
+        return null;
+    return element("ul", {
+        class: "phone-list",
+        children: phone.devices.map((device) => element("li", {
+            key: device.deviceId,
+            children: [
+                `${device.name} (${device.platform}) ${device.removedAt === null ? device.state : "removed"}`,
+                device.removedAt === null
+                    ? phoneButton("Remove", () => {
+                        phone.onRemove(device.deviceId);
+                    })
+                    : null,
+            ],
+        })),
+    });
+}
+export function phoneNotices(phone) {
+    const lines = [
+        phone.reason === "registration-lost" ? "Connect your phones again." : null,
+        phone.connected === null ? null : `Connected: ${phone.connected}`,
+        phone.refusal === null ? null : refusalText(phone.refusal),
+        phone.message === "" ? null : phone.message,
+    ];
+    return lines.map((line) => line === null ? null : element("p", { role: "status", children: line }));
+}
+export function PhonePanel(props) {
+    const { phone, now } = props;
+    const waiting = phone.request === null ? phone.pairing : null;
+    return element("section", {
+        class: waiting === null ? "phone" : "phone phone-pairing",
+        children: [
+            waiting === null
+                ? null
+                : component(PhoneCode, { picture: waiting.picture }),
+            element("div", {
+                children: [
+                    waiting === null
+                        ? null
+                        : [
+                            element("strong", { children: "Scan with your phone camera" }),
+                            element("span", { children: timeLeft(waiting.expiresAt, now) }),
+                        ],
+                    component(PhoneAsk, { phone }),
+                    phone.pairing === null
+                        ? element("button", {
+                            type: "button",
+                            disabled: phone.busy,
+                            onClick: phone.onPair,
+                            children: "Connect a phone",
+                        })
+                        : phoneButton("Cancel", phone.onCancel),
+                    phoneNotices(phone),
+                ],
+            }),
+            component(PhoneList, { phone }),
+        ],
+    });
+}

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

@@ -0,0 +1,5 @@
+import type { IncomingMessage } from "node:http";
+import { type WatchActions } from "./watch-actions.ts";
+export declare function isPhoneAction(path: string): boolean;
+export declare function phoneAction(actions: WatchActions, request: IncomingMessage): Promise<string | null>;
+export declare function phoneRead(runtimeDirectory: string): Promise<string>;

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

@@ -0,0 +1,53 @@
+import { qrMatrix } from "../phone/qr-matrix.js";
+import { qrPicture } from "../phone/qr-picture.js";
+import { phoneRequest } from "./phone-client.js";
+import { actionAllowed, actionBody, } from "./watch-actions.js";
+const operations = {
+    "/actions/phone/pair": "phone-pair-start",
+    "/actions/phone/cancel": "phone-pair-cancel",
+    "/actions/phone/accept": "phone-pair-accept",
+    "/actions/phone/deny": "phone-pair-deny",
+    "/actions/phone/remove": "phone-remove",
+};
+export function isPhoneAction(path) {
+    return Object.hasOwn(operations, path);
+}
+function withPicture(result) {
+    const link = result["link"];
+    return typeof link === "string"
+        ? { ...result, picture: qrPicture(qrMatrix(link).modules) }
+        : result;
+}
+export async function phoneAction(actions, request) {
+    const operation = operations[new URL(String(request.url), "http://localhost").pathname];
+    if (operation === undefined || !actionAllowed(actions, request))
+        return null;
+    const body = await actionBody(request);
+    if (typeof body !== "object" || body === null || Array.isArray(body))
+        return null;
+    const reply = await phoneRequest(actions.runtimeDirectory, {
+        operation,
+        parameters: { ...body },
+    });
+    if (reply === undefined)
+        return JSON.stringify({
+            error: {
+                code: "phone-relay-off",
+                detail: "The phone relay is off or not started.",
+            },
+        });
+    return JSON.stringify(reply.kind === "result"
+        ? withPicture(reply.result)
+        : { error: reply.error });
+}
+export async function phoneRead(runtimeDirectory) {
+    const reply = await phoneRequest(runtimeDirectory, {
+        operation: "phone-state",
+        parameters: {},
+    });
+    if (reply === undefined)
+        return JSON.stringify({ relay: "off" });
+    return JSON.stringify(reply.kind === "result"
+        ? { relay: "on", ...reply.result }
+        : { relay: "on", error: reply.error });
+}

package/dist/src/cli/watch-pr-board.js

@@ -2,7 +2,7 @@ function observedCard(context, card) {
     if (card.completionMark?.text !== "Needs attention")
         return card;
     const run = context.model.runs.find((run) => run.runId === card.runId);
-    if (run?.workflowId !== "develop-issue" ||
+    if (run === undefined ||
         run.state !== "completed" ||
         run.outcome !== "blocked" ||
         run.pullRequest === null)

package/dist/src/cli/watch-pr-command.d.ts

@@ -6,6 +6,7 @@ export interface WatchCommandOutput {
     readonly errorCode: string | null;
 }
 export interface WatchCommandRequest {
+    readonly outputBytes?: number;
     readonly command: readonly string[];
     readonly directory: string;
     readonly signal: AbortSignal;

package/dist/src/cli/watch-pull-request.d.ts

@@ -1,10 +1,12 @@
+import type { CiRerunNotice } from "./github-ci-progress.ts";
 import type { WatchRun } from "./watch-render.ts";
 import { type PrRepository } from "./watch-pr-identity.ts";
 export interface GithubRecords {
     readonly started: unknown;
     readonly result: unknown;
+    readonly ciReruns?: readonly CiRerunNotice[];
 }
 export declare function pullOf(inputs: {
     readonly records: readonly GithubRecords[];
     readonly repository: PrRepository | null;
-}, runId: string): Pick<WatchRun, "pullRequest" | "reviews" | "mergeCommit" | "mergeProof">;
+}, runId: string): Pick<WatchRun, "pullRequest" | "reviews" | "mergeCommit" | "mergeProof" | "ciReruns">;

package/dist/src/cli/watch-pull-request.js

@@ -23,6 +23,11 @@ function list(value) {
 function count(value) {
     return typeof value === "number" ? value : null;
 }
+function methodScope(method, operation) {
+    if (operation[3] === "pull-request")
+        return operation[4] === `github-${method}`;
+    return (method === "merge" && operation[3] === "merge" && operation[4] === "merge");
+}
 function attributed(started, operation) {
     const stage = list(operation[5]);
     const checked = operationIdentity({
@@ -37,8 +42,7 @@ function attributed(started, operation) {
     });
     return (checked.kind === "valid" &&
         checked.value === JSON.stringify(operation) &&
-        operation[3] === "pull-request" &&
-        operation[4] === `github-${text(started["method"])}` &&
+        methodScope(text(started["method"]), operation) &&
         (started["runId"] === undefined || started["runId"] === operation[2]));
 }
 function githubOf(records) {
@@ -47,22 +51,28 @@ function githubOf(records) {
     const result = record(records.result);
     const completed = result["outcome"] === "completed";
     return {
-        runId: text(operation[2]),
+        runId: started["runId"] === undefined || started["runId"] === operation[2]
+            ? text(operation[2])
+            : "",
         round: Number(operation[1]),
+        startedAt: Date.parse(text(started["startedAt"])) || 0,
         method: text(started["method"]),
         completed,
         attributed: attributed(started, operation) && !Object.hasOwn(result, "reason"),
         report: completed ? record(parsed(text(result["result"]))) : {},
     };
 }
-function pullRequestOf(results) {
+function pullRequestOf(results, repository) {
     const opened = results
-        .filter((item) => item.method === "open-pr")
+        .filter((item) => item.method === "open-pr" && item.completed)
         .map((item) => item.report)
         .findLast((report) => text(report["url"]).startsWith("https://"));
     if (opened === undefined)
         return null;
-    return { number: Number(opened["number"]), url: text(opened["url"]) };
+    const pull = { number: Number(opened["number"]), url: text(opened["url"]) };
+    return repository === null || prIdentity(repository, pull) !== null
+        ? pull
+        : null;
 }
 function reviewsOf(results) {
     return results
@@ -115,16 +125,20 @@ export function pullOf(inputs, runId) {
     const results = inputs.records
         .map(githubOf)
         .filter((item) => item.runId === runId)
-        .toSorted((first, second) => first.round - second.round);
-    const pullRequest = pullRequestOf(results);
+        .toSorted((first, second) => first.round - second.round || first.startedAt - second.startedAt);
+    const pullRequest = pullRequestOf(results, inputs.repository);
     const mergeProof = mergeProofOf(results, {
         repository: inputs.repository,
         pullRequest,
     });
+    const ciReruns = inputs.records
+        .filter((item) => record(item.started)["runId"] === runId)
+        .flatMap((item) => item.ciReruns ?? []);
     return {
         pullRequest,
         reviews: reviewsOf(results),
         mergeCommit: mergeCommitOf(results),
+        ...(ciReruns.length === 0 ? {} : { ciReruns }),
         ...(mergeProof === null ? {} : { mergeProof }),
     };
 }

package/dist/src/cli/watch-reads.d.ts

@@ -1,4 +1,5 @@
 import { type PrRepository } from "./watch-pr-identity.ts";
+import { type ShownSchedules } from "./schedule-render.ts";
 import { type WorkflowStages } from "../workflow-declaration.ts";
 import { type Fields } from "../protocol.ts";
 import { type WorkflowRefusal } from "../workflow-refusals.ts";
@@ -16,6 +17,7 @@ interface ReadRun {
     readonly events: readonly ReadEvent[];
 }
 export interface WatchRead {
+    readonly schedules?: ShownSchedules;
     readonly queue?: Fields;
     readonly service: string;
     readonly workflows: readonly string[];

package/dist/src/cli/watch-reads.js

@@ -1,4 +1,5 @@
 import { establishedIssue } from "./watch-pr-identity.js";
+import { shownSchedules } from "./schedule-render.js";
 import { isWorkflowStages, } from "../workflow-declaration.js";
 import { record } from "../protocol.js";
 import { send } from "./client.js";
@@ -86,7 +87,6 @@ async function creationOf(reader, runId) {
 function matchingCompletion(status, context) {
     const issue = establishedIssue(context.repository, status["issueIdentity"]);
     return (status.state === "completed" &&
-        status["workflowId"] === "develop-issue" &&
         record(status["outcome"])?.["kind"] === "handoff_requested" &&
         record(status["outcome"])?.["ticketStatus"] !== "partial" &&
         record(status["outcome"])?.["issueUpdate"] !== "failed" &&
@@ -127,20 +127,17 @@ async function completionOf(reader, search) {
     reader.completions.set(runId, { ...known, creation });
     return { status: known.status, events: creation === null ? [] : [creation] };
 }
-function refreshedLinks(run, status) {
-    const links = Object.fromEntries(["parentRunId", "chainId", "childRunIds"]
+function refreshedStatus(run, status) {
+    const links = Object.fromEntries(["parentRunId", "chainId", "childRunIds", "commandWaits"]
         .filter((name) => Object.hasOwn(status, name))
         .map((name) => [name, status[name]]));
-    return {
-        ...run,
-        status: { ...run.status, ...links },
-    };
+    return { ...run, status: { ...run.status, ...links } };
 }
 async function detailed(reader, summary) {
     const { runId, latestSequence: sequence } = summary;
     const known = reader.details.get(runId);
     if (known !== undefined && known.sequence === sequence)
-        return refreshedLinks(known.value, summary);
+        return refreshedStatus(known.value, summary);
     const shown = await asked(reader, {
         operation: "status",
         parameters: { runId },
@@ -181,13 +178,14 @@ function stoppedIssues(runs, context) {
     const stopped = runs
         .map((run) => run.status)
         .filter((status) => recentRun(status.latestAt, context.now) &&
-        status["workflowId"] === "develop-issue" &&
         (["failed", "cancelled"].includes(status.state) ||
             (status.state === "completed" &&
                 record(status["outcome"])?.["kind"] === "blocked")))
-        .toSorted((first, second) => Date.parse(second.latestAt ?? "") - Date.parse(first.latestAt ?? ""))
-        .slice(0, 20);
-    return new Set(stopped.flatMap((status) => {
+        .toSorted((first, second) => Date.parse(second.latestAt ?? "") - Date.parse(first.latestAt ?? ""));
+    const retained = [
+        ...Map.groupBy(stopped, (status) => status["workflowId"]).values(),
+    ].flatMap((group) => group.slice(0, 20));
+    return new Set(retained.flatMap((status) => {
         const issue = establishedIssue(context.repository, status["issueIdentity"]);
         return status.state === "completed" && issue !== null
             ? [JSON.stringify(issue)]
@@ -213,9 +211,7 @@ async function service(reader, now) {
     const issues = stoppedIssues(runs, { now, repository: reader.repository });
     const older = issues.size === 0
         ? []
-        : summaries.filter((summary) => !recentRun(summary.latestAt, now) &&
-            summary["workflowId"] === "develop-issue" &&
-            summary.state === "completed");
+        : summaries.filter((summary) => !recentRun(summary.latestAt, now) && summary.state === "completed");
     for (const summary of older) {
         const candidate = await completionOf(reader, { summary, issues });
         if (candidate !== null)
@@ -223,6 +219,9 @@ async function service(reader, now) {
     }
     return {
         service: "up",
+        ...("schedules" in status
+            ? { schedules: shownSchedules(status["schedules"]) }
+            : {}),
         ...(record(status["queue"]) === undefined
             ? {}
             : { queue: record(status["queue"]) ?? {} }),
@@ -247,11 +246,13 @@ async function singleRun(reader, runId) {
     const status = statusOf(reply.result["run"]);
     const known = reader.details.get(runId);
     const value = known !== undefined && known.sequence === status.latestSequence
-        ? refreshedLinks(known.value, status)
+        ? refreshedStatus(known.value, status)
         : await remember(reader, status);
+    const metadata = await asked(reader, { operation: "status", parameters: {} });
     return {
         ...unavailable,
         service: "up",
+        workflowStages: stageMetadata(metadata["workflowStages"]),
         runs: [value],
         decisions: await decisionsOf(reader),
     };

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

@@ -1,5 +1,9 @@
+import type { ShownSchedule, ShownSchedules } from "./schedule-render.ts";
+import type { CommandWaitView } from "../authority/command-wait-view.ts";
+import type { CommandEffect } from "../command-settings.ts";
 import type { CardForm } from "./watch-run-input.ts";
-import type { WorkerUsage } from "../worker-usage.ts";
+import type { CiRerunNotice } from "./github-ci-progress.ts";
+import type { WorkerUsage, WorkerAttemptUsage } from "../worker-usage.ts";
 import type { PrIdentity, PrObservation } from "./watch-pr-identity.ts";
 import type { WorkflowRefusal } from "../workflow-refusals.ts";
 import type { Fields } from "../protocol.ts";
@@ -9,6 +13,8 @@ export interface WatchItem {
     readonly costUsd?: number;
 }
 export interface WatchTurn {
+    readonly attempts?: readonly WorkerAttemptUsage[];
+    readonly harness?: string;
     readonly estimatedCostUsd: number | null;
     readonly operationId: string;
     readonly usage: WorkerUsage;
@@ -64,6 +70,13 @@ export interface WatchStep {
     readonly startedAt: string | null;
 }
 export interface WatchCard {
+    readonly scheduled?: {
+        readonly slot: number;
+    };
+    readonly commandWaits?: readonly CommandWaitView[];
+    readonly spent?: number | null;
+    readonly limit?: number | null;
+    readonly awaitedRunId?: string | null;
     readonly parentRunId?: string | null;
     readonly chainId?: string;
     readonly childRunIds?: readonly string[];
@@ -90,6 +103,7 @@ export interface WatchColumn {
     readonly cards: readonly WatchCard[];
 }
 export interface WatchWorkflow {
+    readonly schedule?: ShownSchedule;
     readonly workflowId: string;
     readonly activeCount: number;
     readonly waitingCount: number;
@@ -97,6 +111,13 @@ export interface WatchWorkflow {
     readonly columns: readonly WatchColumn[];
 }
 export interface WatchRun {
+    readonly scheduled?: {
+        readonly slot: number;
+    };
+    readonly commandWaits?: readonly CommandWaitView[];
+    readonly awaitedRunId?: string | null;
+    readonly commandEffects?: readonly CommandEffect[];
+    readonly ciReruns?: readonly CiRerunNotice[];
     readonly parentRunId?: string | null;
     readonly chainId?: string;
     readonly childRunIds?: readonly string[];
@@ -132,6 +153,7 @@ export interface WatchRun {
     readonly mergeCommit: string | null;
 }
 export interface WatchModel {
+    readonly schedules?: ShownSchedules;
     readonly queue?: Fields;
     readonly workflowRefusals?: readonly WorkflowRefusal[];
     readonly cardForms?: readonly CardForm[];

package/dist/src/cli/watch-run-input.d.ts

@@ -10,5 +10,4 @@ export interface CardForm {
     readonly source: "ticket" | "prompt" | "input";
     readonly fields: readonly CardField[];
 }
-export declare function builtinCardForms(): readonly CardForm[];
 export declare function cardRunRequest(forms: readonly CardForm[], value: unknown): ServiceRequest | null;

package/dist/src/cli/watch-run-input.js

@@ -1,17 +1,4 @@
 import { record } from "../protocol.js";
-export function builtinCardForms() {
-    const entries = [
-        ["develop-issue", "ticket", "Issue number"],
-        ["develop-ticket", "ticket", "Ticket ID"],
-        ["develop-prd", "prompt", "Idea"],
-        ["develop-prompt", "prompt", "Task"],
-    ];
-    return entries.map(([workflowId, name, label]) => ({
-        workflowId,
-        source: name === "ticket" ? "ticket" : "prompt",
-        fields: [{ name, label, multiline: name === "prompt", optional: false }],
-    }));
-}
 function validFields(form, fields) {
     if (Object.keys(fields).some((name) => !form.fields.some((field) => field.name === name)))
         return false;

package/dist/src/cli/watch-server.js

@@ -1,5 +1,6 @@
 import { watchAction, watchActions, watchHost, } from "./watch-actions.js";
 import { observedBoard } from "./watch-pr-board.js";
+import { isPhoneAction, phoneAction, phoneRead } from "./watch-phone.js";
 import { watchPrObserver } from "./watch-pr-settings.js";
 import { readdir, readFile, stat } from "node:fs/promises";
 import { createServer, } from "node:http";
@@ -7,7 +8,8 @@ import { homedir } from "node:os";
 import { dirname, join } from "node:path";
 import { fileURLToPath } from "node:url";
 import { watchReader } from "./watch-reads.js";
-import { turnOf, watchModel } from "./watch-model.js";
+import { ciRerunNotices } from "./github-ci-progress.js";
+import { turnActivity, turnOf, watchModel, } from "./watch-model.js";
 import { pageDocument } from "./watch-page.js";
 import { watchStream } from "./watch-stream.js";
 export const defaultWatchPort = 3663;
@@ -37,7 +39,7 @@ function parsed(text) {
         return null;
     }
 }
-const noStream = { size: 0, lines: [], activeAt: null };
+const noStream = { size: 0, activity: [], activeAt: null };
 async function streamed(watch, file) {
     const found = await stat(file).catch(() => null);
     if (found === null)
@@ -46,9 +48,9 @@ async function streamed(watch, file) {
     const activeAt = found.mtime.toISOString();
     if (known?.size === found.size)
         return { ...known, activeAt };
-    const lines = (await readFile(file, "utf8").catch(() => "")).split("\n");
-    watch.streams.set(file, { size: found.size, lines });
-    return { size: found.size, lines, activeAt };
+    const activity = turnActivity((await readFile(file, "utf8").catch(() => "")).split("\n"));
+    watch.streams.set(file, { size: found.size, activity });
+    return { size: found.size, activity, activeAt };
 }
 async function stored(file) {
     return parsed(await readFile(file, "utf8").catch(() => "null"));
@@ -65,7 +67,7 @@ async function turns(watch) {
             key,
             started,
             result: await stored(join(journal, key, "result.json")),
-            lines: stream.lines,
+            activity: stream.activity,
             activeAt: stream.activeAt,
         }));
     }
@@ -82,7 +84,11 @@ async function githubRecords(watch) {
         if (started === null)
             continue;
         const result = await stored(join(journal, key, "result.json"));
-        watch.github.set(key, { started, result });
+        watch.github.set(key, {
+            started,
+            result,
+            ciReruns: await ciRerunNotices(join(journal, key)),
+        });
     }
     return keys.flatMap((key) => watch.github.get(key) ?? []);
 }
@@ -121,6 +127,11 @@ async function fontReply(request) {
         cache: "public, max-age=31536000, immutable",
     };
 }
+function routedAction(path) {
+    if (isPhoneAction(path))
+        return phoneAction;
+    return path === "/actions/run" ? watchAction : null;
+}
 async function answered(watch, request) {
     if (!watchHost(request))
         return forbidden;
@@ -130,11 +141,12 @@ async function answered(watch, request) {
     const url = new URL(String(request.url), "http://localhost");
     if (request.method === "GET")
         return readReply(watch, url);
-    if (request.method !== "POST" ||
-        url.pathname !== "/actions/run" ||
-        watch.actions === null)
+    if (request.method !== "POST" || watch.actions === null)
+        return notFound;
+    const act = routedAction(url.pathname);
+    if (act === null)
         return notFound;
-    const body = await watchAction(watch.actions, request).catch(() => null);
+    const body = await act(watch.actions, request).catch(() => null);
     return body === null
         ? forbidden
         : { status: 200, type: "application/json", body };
@@ -153,6 +165,12 @@ async function readReply(watch, url) {
             type: "text/javascript; charset=utf-8",
             body: await readFile(libraryFile, "utf8"),
         };
+    if (path === "/phone.json")
+        return {
+            status: 200,
+            type: "application/json",
+            body: await phoneRead(watch.settings.runtimeDirectory),
+        };
     if (path !== "/data.json")
         return notFound;
     const runId = url.searchParams.get("runId");

package/dist/src/cli/watch-turn.d.ts

@@ -1,5 +1,5 @@
 import { type Shown } from "./watch-element.ts";
-import { type Copying, type WatchDecision, type WatchEvent, type WatchItem, type WatchTurn } from "./watch-render.ts";
+import { type Copying, type WatchDecision, type WatchEvent, type WatchItem, type WatchRun, type WatchTurn } from "./watch-render.ts";
 export declare function Item(props: {
     readonly item: WatchItem;
 }): Shown;
@@ -28,3 +28,6 @@ export declare function Decision(props: {
 export declare function Events(props: {
     readonly events: readonly WatchEvent[];
 }): Shown;
+export declare function PullRequest(props: {
+    readonly run: WatchRun;
+}): Shown;

package/dist/src/cli/watch-turn.js

@@ -1,4 +1,4 @@
-import { priceText, usageText } from "./usage-render.js";
+import { priceText, usageText, attemptText } from "./usage-render.js";
 import { component, element } from "./watch-element.js";
 import { clockTime, counted, groupActivity, turnTime, } from "./watch-render.js";
 export function Item(props) {
@@ -43,10 +43,17 @@ export function Turn(props) {
                 children: heading.filter((part) => part !== "").join(" · "),
             }),
             element("p", { class: "meta", children: place }),
+            turn.harness === undefined
+                ? null
+                : element("p", { class: "meta", children: `Harness: ${turn.harness}` }),
             element("p", {
                 class: "turn-usage",
                 children: usageText(turn.usage),
             }),
+            ...(turn.attempts ?? []).map((attempt) => element("p", {
+                class: "turn-attempt",
+                children: attemptText(attempt),
+            })),
             element("div", { class: "activity", children: activity }),
         ],
     });
@@ -133,3 +140,32 @@ export function Events(props) {
         ],
     });
 }
+export function PullRequest(props) {
+    const { pullRequest, reviews, mergeCommit } = props.run;
+    if (pullRequest === null)
+        return null;
+    const link = element("a", {
+        href: pullRequest.url,
+        children: `#${String(pullRequest.number)}`,
+    });
+    const scores = reviews.map((review) => element("li", {
+        children: `Round ${String(review.round)} · Review ${String(review.score)}/5 · commit ${review.commit.slice(0, 7)}`,
+    }));
+    const merge = mergeCommit === null
+        ? null
+        : element("p", {
+            class: "meta",
+            children: [
+                "Merge commit ",
+                element("code", { children: mergeCommit }),
+            ],
+        });
+    return element("section", {
+        class: "pull",
+        children: [
+            element("h3", { children: ["Pull request ", link] }),
+            element("ul", { class: "reviews", children: scores }),
+            merge,
+        ],
+    });
+}