cloving 1.2.0 → 1.3.0

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

@@ -121,10 +121,14 @@ export function pullOf(inputs, runId) {
         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-render.d.ts

@@ -1,5 +1,7 @@
+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 +11,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 +68,7 @@ export interface WatchStep {
     readonly startedAt: string | null;
 }
 export interface WatchCard {
+    readonly awaitedRunId?: string | null;
     readonly parentRunId?: string | null;
     readonly chainId?: string;
     readonly childRunIds?: readonly string[];
@@ -97,6 +102,9 @@ export interface WatchWorkflow {
     readonly columns: readonly WatchColumn[];
 }
 export interface WatchRun {
+    readonly awaitedRunId?: string | null;
+    readonly commandEffects?: readonly CommandEffect[];
+    readonly ciReruns?: readonly CiRerunNotice[];
     readonly parentRunId?: string | null;
     readonly chainId?: string;
     readonly childRunIds?: readonly string[];

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,6 +8,7 @@ import { homedir } from "node:os";
 import { dirname, join } from "node:path";
 import { fileURLToPath } from "node:url";
 import { watchReader } from "./watch-reads.js";
+import { ciRerunNotices } from "./github-ci-progress.js";
 import { turnOf, watchModel } from "./watch-model.js";
 import { pageDocument } from "./watch-page.js";
 import { watchStream } from "./watch-stream.js";
@@ -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,
+        ],
+    });
+}

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

@@ -1,5 +1,5 @@
 import { record } from "../protocol.js";
-import { priceOf, usageOf } from "../worker-usage.js";
+import { priceOf, usageOf, attemptFields } from "../worker-usage.js";
 function text(value) {
     return typeof value === "string" ? value : "";
 }
@@ -41,6 +41,10 @@ export function statusTurns(turns, status) {
             emptyTurn(operationId, runId);
         return {
             ...known,
+            ...attemptFields(fields["attempts"]),
+            ...(typeof fields["harness"] === "string"
+                ? { harness: fields["harness"] }
+                : {}),
             runId,
             operationId,
             outcome: known.outcome === "in work" ? "ended" : known.outcome,

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

@@ -1,18 +1,16 @@
 import type { CardControls } from "./watch-card-view.ts";
+import type { PhoneControls } from "./watch-phone-view.ts";
+import { type StartControls } from "./watch-header-view.ts";
+export { clove, Header } from "./watch-header-view.ts";
+export type { StartControls } from "./watch-header-view.ts";
 import { type Shown } from "./watch-element.ts";
 import { type Copying, type WatchModel, type WatchPhase, type WatchRun } from "./watch-render.ts";
 import { type ColumnControls } from "./watch-board-view.ts";
-export declare function Queue(props: {
-    readonly model: WatchModel;
-}): Shown;
+export { PullRequest } from "./watch-turn.ts";
 interface Timed {
     readonly run: WatchRun;
     readonly now: string;
 }
-export declare const clove: {
-    viewBox: string;
-    paths: string[];
-};
 export declare function BannerDetail(props: Timed): Shown;
 export declare function Banner(props: Timed): Shown;
 export declare function Phases(props: {
@@ -23,21 +21,9 @@ export declare function Review(props: {
     readonly run: WatchRun;
     readonly round: number;
 }): Shown;
-export declare function PullRequest(props: {
-    readonly run: WatchRun;
-}): Shown;
 export declare function Run(props: Timed & {
     readonly copying: Copying;
 }): Shown;
-export interface StartControls {
-    readonly shown: boolean;
-    readonly onToggle: () => void;
-}
-export declare function Header(props: {
-    readonly model: WatchModel | null;
-    readonly stale: boolean;
-    readonly start?: StartControls;
-}): Shown;
 export interface PageProps {
     readonly cards?: CardControls;
     readonly model: WatchModel | null;
@@ -48,6 +34,7 @@ export interface PageProps {
     readonly copying: Copying;
     readonly columns?: ColumnControls;
     readonly start?: StartControls;
+    readonly phone?: PhoneControls | undefined;
 }
 export declare function RefusedWorkflows(props: {
     readonly model: WatchModel;
@@ -58,4 +45,3 @@ export declare function BoardPage(props: PageProps & {
     readonly workflowId: string | null;
     readonly down: Shown;
 }): Shown;
-export {};

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

@@ -1,45 +1,14 @@
+import { Header, Queue } from "./watch-header-view.js";
+export { clove, Header } from "./watch-header-view.js";
 import { priceText, usageText, totalsSuffix } from "./usage-render.js";
 import { component, element } from "./watch-element.js";
-import { clockTime, completedDetail, counted, elapsed, phaseTime, runName, runTone, waitingDetail, } from "./watch-render.js";
+import { completedDetail, counted, elapsed, phaseTime, runName, runTone, waitingDetail, } from "./watch-render.js";
 import { Board, HandoffLinks, WorkflowList, } from "./watch-board-view.js";
 import { boardWorkflow, watchHash, watchLocation } from "./watch-navigation.js";
-import { Decision, Events, Turn } from "./watch-turn.js";
+import { Decision, Events, Turn, PullRequest } from "./watch-turn.js";
+import { Commands } from "./command-effects.js";
+export { PullRequest } from "./watch-turn.js";
 import { StartRun } from "./watch-start-view.js";
-import { record } from "../protocol.js";
-export function Queue(props) {
-    const queue = props.model.queue;
-    if (queue === undefined)
-        return null;
-    const skipped = Array.isArray(queue["skipped"])
-        ? queue["skipped"]
-        : [];
-    return [
-        element("p", {
-            class: "meta",
-            children: `Queue: ${String(queue["busy"])} of ${String(queue["lanes"])} lanes busy`,
-        }),
-        ...skipped.map((value) => {
-            const ticket = record(value) ?? {};
-            const dependencies = ticket["dependencies"];
-            const needs = Array.isArray(dependencies)
-                ? `; needs ${dependencies.map(String).join(", ")}`
-                : "";
-            return element("p", {
-                class: "meta",
-                children: `Skipped ticket ${String(ticket["ticketId"])}: ${String(ticket["reason"])}${needs}`,
-            });
-        }),
-    ];
-}
-export const clove = {
-    viewBox: "0.6625858545303345 0.6630800366401672 46.674827575683594 46.673831939697266",
-    paths: [
-        "M41.47315,11.48535c-1.20117-0.12305-2.16211-1.08398-2.28418-2.28516c-0.17676-1.7334-1.01758-3.29492-2.36865-4.39648s-3.05078-1.61719-4.7832-1.43359c-3.34277,0.34082-5.86377,3.13086-5.86377,6.49121v14.13867c0,0.27637,0.22363,0.5,0.5,0.5H40.8125c3.59766,0,6.52441-2.92676,6.52441-6.52441C47.33692,14.61523,44.81592,11.82422,41.47315,11.48535z M35.56543,15.81543l-5.85791,5.85742c-0.09766,0.09766-0.22559,0.14648-0.35352,0.14648s-0.25586-0.04883-0.35352-0.14648c-0.19531-0.19531-0.19531-0.51172,0-0.70703l5.85791-5.85742c0.19531-0.19531,0.51172-0.19531,0.70703,0C35.76073,15.30372,35.76074,15.62011,35.56543,15.81543z",
-        "M15.30225,0.66308c-3.36035,0-6.15088,2.52051-6.49121,5.86328C8.68897,7.72852,7.72852,8.68945,6.52686,8.81152c-1.7334,0.17578-3.29492,1.01758-4.396,2.36816s-1.61035,3.0498-1.43408,4.7832c0.34033,3.34277,3.13086,5.86328,6.49121,5.86328h14.13867c0.27637,0,0.5-0.22363,0.5-0.5V7.18751C21.82666,3.58984,18.8999,0.66308,15.30225,0.66308z M18.99951,19.00001c-0.09766,0.09766-0.22559,0.14648-0.35352,0.14648s-0.25586-0.04883-0.35352-0.14648l-5.85742-5.8584c-0.19531-0.19531-0.19531-0.51172,0-0.70703c0.19531-0.19531,0.51172-0.19531,0.70703,0l5.85742,5.8584C19.19482,18.48829,19.19482,18.80469,18.99951,19.00001z",
-        "M24,26.17383H9.86133c-3.59766,0-6.52441,2.92676-6.52441,6.52441c0,3.35938,2.52051,6.14941,5.86377,6.49023c1.20117,0.12207,2.16211,1.08301,2.28418,2.28418c0.17676,1.7334,1.01758,3.29492,2.36865,4.39648c1.17529,0.95801,2.61377,1.46777,4.11035,1.46777c0.22314,0,0.44775-0.01074,0.67285-0.03418C21.97949,46.96189,24.5,44.17186,24.5,40.81248V26.67383C24.5,26.39746,24.27637,26.17383,24,26.17383z M21.67334,29.70704l-5.85791,5.8584c-0.09766,0.09766-0.22559,0.14648-0.35352,0.14648s-0.25586-0.04883-0.35352-0.14648c-0.19531-0.19531-0.19531-0.51172,0-0.70703L20.9663,29c0.19531-0.19531,0.51172-0.19531,0.70703,0S21.86865,29.51172,21.67334,29.70704z",
-        "M47.30322,32.03711c-0.34033-3.34277-3.13086-5.86328-6.49072-5.86328H26.67334c-0.27637,0-0.5,0.22363-0.5,0.5V40.8125c0,3.59766,2.92676,6.52441,6.52442,6.52441c3.36035,0,6.15088-2.52148,6.49121-5.86426c0.12207-1.20117,1.08301-2.16211,2.28418-2.28418c1.7334-0.17578,3.29492-1.01758,4.396-2.36816S47.47949,33.7705,47.30322,32.03711z M35.56543,35.56543c-0.09766,0.09766-0.22559,0.14648-0.35352,0.14648s-0.25586-0.04883-0.35352-0.14648l-5.85791-5.8584c-0.19531-0.19531-0.19531-0.51172,0-0.70703s0.51172-0.19531,0.70703,0l5.85791,5.8584C35.76074,35.05371,35.76074,35.37011,35.56543,35.56543z",
-    ],
-};
 export function BannerDetail(props) {
     const { run, now } = props;
     const turn = run.turns.at(-1);
@@ -54,8 +23,9 @@ export function BannerDetail(props) {
         ? ""
         : ` · last output ${elapsed(turn.activeAt, now)} ago`;
     const last = turn.activity.at(-1)?.text ?? "The worker starts.";
+    const worker = turn.harness === undefined ? "The worker" : `The ${turn.harness} worker`;
     return [
-        `Claude works for ${elapsed(turn.startedAt, now)} · ${counted(calls, "tool call")}${quiet}`,
+        `${worker} works for ${elapsed(turn.startedAt, now)} · ${counted(calls, "tool call")}${quiet}`,
         element("span", { class: "now", children: last }),
     ];
 }
@@ -115,35 +85,6 @@ export function Review(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,
-        ],
-    });
-}
 export function Run(props) {
     const { run, now, copying } = props;
     const turn = run.turns.at(-1);
@@ -181,50 +122,17 @@ export function Run(props) {
         }),
         component(Phases, { phases: run.phases, now }),
         component(PullRequest, { run }),
+        (run.ciReruns ?? []).map((rerun) => element("p", {
+            class: "meta",
+            children: `CI rerun after a failed check: workflow ${rerun.run}, commit ${rerun.commit.slice(0, 7)}`,
+        })),
         run.decisions.map((decision) => component(Decision, { decision, turn, copying })),
         turns,
+        component(Commands, { effects: run.commandEffects ?? [] }),
         component(Events, { events: run.events }),
         element("p", { class: "meta foot", children: foot }),
     ];
 }
-export function Header(props) {
-    const { model, stale } = props;
-    const updated = model === null ? "" : `updated ${clockTime(model.updatedAt)}`;
-    const stamp = stale
-        ? element("span", {
-            class: "bad",
-            children: "The watch tool does not answer.",
-        })
-        : element("span", { children: updated });
-    return element("header", {
-        children: [
-            element("strong", {
-                class: "brand",
-                children: [
-                    element("svg", {
-                        xmlns: "http://www.w3.org/2000/svg",
-                        "aria-hidden": "true",
-                        focusable: "false",
-                        viewBox: clove.viewBox,
-                        children: clove.paths.map((d) => element("path", { fill: "currentColor", d })),
-                    }),
-                    "cloving",
-                ],
-            }),
-            stamp,
-            props.start === undefined
-                ? null
-                : element("button", {
-                    type: "button",
-                    class: "start-toggle",
-                    "aria-controls": "start-run",
-                    "aria-expanded": String(props.start.shown),
-                    onClick: props.start.onToggle,
-                    children: "Start a run",
-                }),
-        ],
-    });
-}
 export function RefusedWorkflows(props) {
     const refusals = props.model.workflowRefusals ?? [];
     if (refusals.length === 0)
@@ -279,7 +187,7 @@ export function BoardPage(props) {
     return element("div", {
         class: "board-page",
         children: [
-            component(Header, { model, stale, start }),
+            component(Header, { model, stale, start, phone: props.phone, now }),
             component(Queue, { model }),
             down,
             component(RefusedWorkflows, { model }),

package/dist/src/cli.js

@@ -1,11 +1,27 @@
 #!/usr/bin/env node
+import { createProbeRunner } from "./cli/probe-command.js";
+import { settingsEnvironment } from "./cli/project-settings.js";
 import { addAbortListener } from "node:events";
-import { execFile, spawn } from "node:child_process";
-import { delimiter, dirname, extname, join } from "node:path";
+import { execFile, execFileSync, spawn } from "node:child_process";
+import { existsSync, realpathSync } from "node:fs";
+import { parseArgs } from "node:util";
+import { delimiter, dirname, extname, join, resolve } from "node:path";
 import { main } from "./cli/main.js";
-import { clientCommand, runtimeDirectory } from "./cli/runtime-directory.js";
+import { parseInvocation } from "./cli/arguments.js";
+import { adoptionRecordPath, clientCommand, legacyRuntimeDirectory, runtimeDirectory, } from "./cli/runtime-directory.js";
 import { commandUsage } from "./cli/usage.js";
 const [command, ...options] = process.argv.slice(2);
+function repositoryDirectory(directory) {
+    try {
+        return realpathSync(execFileSync("git", ["-C", resolve(directory), "rev-parse", "--show-toplevel"], {
+            encoding: "utf8",
+            stdio: ["ignore", "pipe", "ignore"],
+        }).trim());
+    }
+    catch {
+        return undefined;
+    }
+}
 const watchCommand = async (request) => {
     const [command = "", ...argumentsList] = request.command;
     const completed = Promise.withResolvers();
@@ -42,17 +58,30 @@ const watchCommand = async (request) => {
         listener[Symbol.dispose]();
     }
 };
-function started(runtime, argumentsList) {
-    const program = join(import.meta.dirname, "..", "tools", `self-host${extname(import.meta.filename)}`);
+function startArguments(input) {
+    const { runtime, repository, argumentsList } = input;
     const located = [
         "--runtime",
-        runtime,
+        runtimeDirectory(process.env, repository) ?? runtime,
         "--repository",
-        process.cwd(),
+        repository ?? process.cwd(),
         "--client",
-        clientCommand(process.env),
+        clientCommand(process.env, repository),
     ];
-    const child = spawn(process.execPath, [program, ...located, ...argumentsList], {
+    const record = repository === undefined
+        ? undefined
+        : adoptionRecordPath(process.env, repository);
+    const legacy = legacyRuntimeDirectory(process.env);
+    if (!process.env["CLOVING_RUNTIME_DIR"] &&
+        record !== undefined &&
+        !existsSync(record) &&
+        legacy !== undefined)
+        located.push("--legacy-runtime", resolve(legacy), "--adoption-record", resolve(record));
+    return [...located, ...argumentsList];
+}
+function toolProcess(input) {
+    const program = join(import.meta.dirname, "..", "tools", `${input.tool}${extname(import.meta.filename)}`);
+    const child = spawn(process.execPath, [program, ...input.argumentsList], {
         stdio: "inherit",
         env: {
             ...process.env,
@@ -78,27 +107,81 @@ function started(runtime, argumentsList) {
         });
     });
 }
+function started(input) {
+    return toolProcess({
+        tool: "self-host",
+        argumentsList: startArguments(input),
+    });
+}
 async function start() {
     if (options.includes("--help")) {
         process.stdout.write(String(commandUsage["start"]));
         return 0;
     }
-    const runtime = runtimeDirectory(process.env);
-    if (runtime !== undefined) {
-        let status = await started(runtime, options);
-        const restarting = options.filter((option) => option !== "--reset-queue");
-        while (status === 75)
-            status = await started(runtime, restarting);
-        return status === 0 ? 0 : 1;
+    const parsed = parseArgs({
+        args: options,
+        options: { repository: { type: "string" } },
+        strict: false,
+        allowPositionals: true,
+    });
+    const selected = parsed.values["repository"];
+    if (Object.hasOwn(parsed.values, "repository") &&
+        (typeof selected !== "string" || selected === "")) {
+        process.stderr.write("missing-value: --repository needs a directory.\n");
+        return 1;
     }
-    process.stderr.write("runtime-directory-unknown: Set CLOVING_RUNTIME_DIR to the runtime directory of the service.\n");
-    return 1;
+    if (parsed.positionals.length > 0) {
+        process.stderr.write("unexpected-argument: run cloving start --help for usage.\n");
+        return 1;
+    }
+    const repository = repositoryDirectory(typeof selected === "string" ? selected : process.cwd());
+    const runtime = runtimeDirectory(process.env, repository);
+    if (runtime === undefined) {
+        process.stderr.write("repository-unknown: Change to the service repository, use --repository <directory>, or set CLOVING_RUNTIME_DIR.\n");
+        return 1;
+    }
+    let status = await started({ runtime, argumentsList: options, repository });
+    const restarting = options.filter((option) => option !== "--reset-queue");
+    while (status === 75)
+        status = await started({
+            runtime,
+            argumentsList: restarting,
+            repository,
+        });
+    return status === 0 ? 0 : 1;
 }
-if (command === "start")
+if (command === "workflows" && ["list", "test"].includes(options[0] ?? ""))
+    process.exitCode = await toolProcess({
+        tool: "workflow-command",
+        argumentsList: options,
+    });
+else if (command === "templates")
+    process.exitCode = await toolProcess({
+        tool: "template-command",
+        argumentsList: options,
+    });
+else if (command === "start")
     process.exitCode = await start();
-else
+else {
+    const invocation = parseInvocation(process.argv.slice(2));
+    const repository = repositoryDirectory("repository" in invocation
+        ? (invocation.repository ?? process.cwd())
+        : process.cwd());
+    const settingsRepository = process.env["CLOVING_WATCH_REPOSITORY"] ?? repository;
+    const environment = invocation.kind === "watch" && settingsRepository !== undefined
+        ? settingsEnvironment(process.env, settingsRepository)
+        : process.env;
     await main(process.argv.slice(2), {
-        repository: process.env["CLOVING_WATCH_REPOSITORY"],
-        githubCommand: process.env["CLOVING_GH_COMMAND"],
-        execute: watchCommand,
+        repository,
+        environment,
+        doctorProbe: createProbeRunner({
+            spawn: (input) => spawn(input.executable, input.arguments, input.options),
+            kill: (identifier, signal) => process.kill(identifier, signal),
+        }),
+        watchPr: {
+            repository: process.env["CLOVING_WATCH_REPOSITORY"],
+            githubCommand: environment["CLOVING_GH_COMMAND"],
+            execute: watchCommand,
+        },
     });
+}

package/dist/src/command-settings.d.ts

@@ -0,0 +1,16 @@
+export type LocalCommands = Readonly<Record<string, readonly string[]>>;
+export declare const commandLimits: {
+    stdoutBytes: number;
+    stderrBytes: number;
+    resultBytes: number;
+};
+export interface CommandEffect {
+    readonly operationId: string;
+    readonly name: string;
+    readonly state: string;
+    readonly exitCode: number | null;
+    readonly durationMilliseconds: number | null;
+}
+export type CommandEffects = (effects: readonly CommandEffect[]) => Promise<readonly CommandEffect[]>;
+export declare function parseCommands(text: string | undefined): LocalCommands;
+export declare function parseCommandSeconds(text: string | undefined): number;

package/dist/src/command-settings.js

@@ -0,0 +1,42 @@
+import { record } from "./protocol.js";
+export const commandLimits = {
+    stdoutBytes: 1_048_576,
+    stderrBytes: 65_536,
+    resultBytes: 3_145_728,
+};
+function argumentsList(value) {
+    return (Array.isArray(value) &&
+        typeof value[0] === "string" &&
+        value[0].startsWith("/") &&
+        Array.from(value).every((argument) => typeof argument === "string" && !argument.includes("\u0000")));
+}
+export function parseCommands(text) {
+    if (text === undefined)
+        return {};
+    try {
+        const fields = record(JSON.parse(text));
+        if (fields === undefined)
+            throw new Error("invalid-commands");
+        const commands = {};
+        for (const [name, argumentList] of Object.entries(fields)) {
+            if (!/^[A-Za-z0-9-]{1,64}$/.test(name) || !argumentsList(argumentList))
+                throw new Error("invalid-commands");
+            commands[name] = [...argumentList];
+        }
+        return commands;
+    }
+    catch {
+        throw new Error("invalid-commands");
+    }
+}
+export function parseCommandSeconds(text) {
+    if (text === undefined)
+        return 60;
+    const seconds = Number(text);
+    if (!/^\d+$/.test(text) ||
+        !Number.isInteger(seconds) ||
+        seconds < 1 ||
+        seconds > 3600)
+        throw new Error("invalid-command-seconds");
+    return seconds;
+}

package/dist/src/configuration-change.d.ts

@@ -0,0 +1,11 @@
+export interface SettingChange {
+    readonly field: string;
+    readonly action: "set" | "unset";
+    readonly value?: string;
+    readonly scope: "project" | "private";
+}
+export type JsonValue = null | boolean | number | string | readonly JsonValue[] | {
+    readonly [name: string]: JsonValue;
+};
+export declare function settingValue(text: string): JsonValue;
+export declare function changedConfiguration(contents: string | undefined, change: SettingChange): string;