cloving 1.3.0 → 1.4.0

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

@@ -5,8 +5,7 @@ const endings = [
 ];
 const review = { open: "gate.opened", close: "gate.decided" };
 const effect = { open: "effect.requested", close: "effect.reported" };
-const issueWorkflow = "develop-issue";
-export const issueSteps = [
+export const pullRequestSteps = [
     { name: "Work tree", operation: "github-prepare" },
     { name: "Agent turn", operation: "claude-turn" },
     { name: "Pull request", operation: "github-open-pr" },
@@ -79,24 +78,82 @@ function operationOf(event) {
         return [];
     }
 }
+export function pullRequestStepOf(event) {
+    const scope = operationOf(record(event));
+    return pullRequestSteps.find((step) => step.operation === scope[4] ||
+        (step.name === "Code review" && scope[3] === "review") ||
+        (step.name === "Merge" && scope[3] === "merge"));
+}
+function stepEffects(events, context) {
+    const { step, round } = context;
+    const repeated = roundOperations.includes(step.operation);
+    const currentTurn = events.findLastIndex((event) => event["type"] === effect.open && operationOf(event)[4] === "claude-turn");
+    const requested = new Set(events
+        .slice(currentTurn + 1)
+        .filter((event) => event["type"] === effect.open)
+        .map((event) => record(event["payload"])["operationId"]));
+    return events.filter((event) => {
+        if (pullRequestStepOf(event) !== step)
+            return false;
+        if (!repeated)
+            return true;
+        const scope = operationOf(event);
+        return roundOperations.includes(String(scope[4]))
+            ? scope[1] === round
+            : requested.has(record(event["payload"])["operationId"]);
+    });
+}
+export function stageOf(event, stages) {
+    const fields = record(event);
+    if ([effect.open, effect.close].includes(String(fields["type"]))) {
+        const operation = operationOf(fields)[4];
+        return stages.find((stage) => stage.operations?.some((name) => name === operation));
+    }
+    const payload = record(fields["payload"]);
+    return (stages.find((stage) => stage.gateIds?.some((name) => name === payload["gateId"])) ??
+        stages.find((stage) => stage.gateKinds?.some((name) => name === payload["gateKind"])));
+}
+function declaredSpans(events, stages) {
+    return stages.map((stage) => {
+        const index = events.findLastIndex((event) => [effect.open, review.open].includes(String(event["type"])) &&
+            stageOf(event, stages) === stage);
+        const opening = events[index];
+        const pair = opening?.["type"] === review.open ? review : effect;
+        const identity = pair === review ? "gateId" : "operationId";
+        const key = record(opening?.["payload"])[identity];
+        const closing = events
+            .slice(index + 1)
+            .findLast((event) => event["type"] === pair.close &&
+            key !== undefined &&
+            record(event["payload"])[identity] === key);
+        const payload = record(closing?.["payload"]);
+        const failed = unfinished.includes(String(payload["outcome"])) ||
+            payload["decision"] === "denied";
+        return {
+            name: stage.label,
+            startedAt: timeOf(opening),
+            endedAt: timeOf(closing),
+            ending: failed ? "failed" : "done",
+        };
+    });
+}
 function currentRound(events) {
     const requested = events.findLast((event) => event["type"] === effect.open && operationOf(event)[4] === "claude-turn");
     const round = operationOf(requested)[1];
     return typeof round === "number" ? round : 1;
 }
-function spans(events, workflowId) {
-    if (workflowId !== issueWorkflow)
+function spans(events, workflow) {
+    if (workflow.stages !== undefined)
+        return [...admission(events), ...declaredSpans(events, workflow.stages)];
+    if (workflow.pullRequest == null)
         return ticketSpans(events);
     const effects = events.filter((event) => [effect.open, effect.close].includes(String(event["type"])));
     const round = currentRound(effects);
     return [
         ...admission(events),
-        ...issueSteps.map((step) => {
+        ...pullRequestSteps.map((step) => {
             const repeated = roundOperations.includes(step.operation);
-            const own = effects.filter((event) => {
-                const scope = operationOf(event);
-                return scope[4] === step.operation && (!repeated || scope[1] === round);
-            });
+            const own = stepEffects(effects, { step, round });
             const last = own.findLast((event) => event["type"] === effect.close);
             const outcome = String(record(last?.["payload"])["outcome"]);
             return {
@@ -132,9 +189,9 @@ function advanced(phases) {
         ? { ...item, state: "active" }
         : item);
 }
-export function phasesOf(events, workflowId = "") {
+export function phasesOf(events, workflow = {}) {
     const known = events.map(record);
-    const steps = spans(known, workflowId);
+    const steps = spans(known, workflow);
     const [end] = ends(known);
     if (end !== undefined)
         return [...steps.map((span) => phase(span, "failed")), end];

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.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,8 +125,8 @@ 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,

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,3 +1,5 @@
+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 { CiRerunNotice } from "./github-ci-progress.ts";
@@ -68,6 +70,12 @@ 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;
@@ -95,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;
@@ -102,6 +111,10 @@ 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[];
@@ -140,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

@@ -9,7 +9,7 @@ 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 { turnActivity, turnOf, watchModel, } from "./watch-model.js";
 import { pageDocument } from "./watch-page.js";
 import { watchStream } from "./watch-stream.js";
 export const defaultWatchPort = 3663;
@@ -39,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)
@@ -48,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"));
@@ -67,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,
         }));
     }

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

@@ -1,8 +1,6 @@
 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";
@@ -33,7 +31,6 @@ export interface PageProps {
     readonly stale: boolean;
     readonly copying: Copying;
     readonly columns?: ColumnControls;
-    readonly start?: StartControls;
     readonly phone?: PhoneControls | undefined;
 }
 export declare function RefusedWorkflows(props: {

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

@@ -1,3 +1,5 @@
+import { scheduledText } from "./schedule-render.js";
+import { CommandWaits, effectBudgetText } from "./command-waits.js";
 import { Header, Queue } from "./watch-header-view.js";
 export { clove, Header } from "./watch-header-view.js";
 import { priceText, usageText, totalsSuffix } from "./usage-render.js";
@@ -8,7 +10,6 @@ import { boardWorkflow, watchHash, watchLocation } from "./watch-navigation.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";
 export function BannerDetail(props) {
     const { run, now } = props;
     const turn = run.turns.at(-1);
@@ -88,9 +89,7 @@ export function Review(props) {
 export function Run(props) {
     const { run, now, copying } = props;
     const turn = run.turns.at(-1);
-    const budget = run.spent === null || run.limit === null
-        ? ""
-        : ` · ${String(run.spent)} of ${String(run.limit)} effect units`;
+    const budget = effectBudgetText(run.spent, run.limit);
     const none = "No agent turn for this run.";
     const turns = run.turns.length === 0
         ? element("p", { class: "meta", children: none })
@@ -103,13 +102,17 @@ export function Run(props) {
             }),
         ]);
     const foot = [
-        `${run.workflowId} · ${run.runId}${budget}`,
+        `${run.workflowId} · ${run.runId}${budget === "" ? "" : ` · ${budget}`}`,
         element("br", {}),
         `${run.code}: ${run.detail}`,
     ];
     return [
         component(Banner, { run, now }),
+        run.scheduled === undefined
+            ? null
+            : element("p", { class: "meta", children: scheduledText(run.scheduled) }),
         component(HandoffLinks, { run }),
+        component(CommandWaits, { waits: run.commandWaits ?? [] }),
         element("section", {
             class: "run-usage",
             children: [
@@ -181,21 +184,18 @@ export function Page(props) {
     return component(BoardPage, { ...props, model, workflowId, down });
 }
 export function BoardPage(props) {
-    const { model, workflowId, down, now, stale, copying } = props;
+    const { model, workflowId, down, now, stale } = props;
     const workflow = model.workflows.find((item) => item.workflowId === workflowId);
-    const start = props.start ?? { shown: false, onToggle: () => undefined };
     return element("div", {
         class: "board-page",
         children: [
-            component(Header, { model, stale, start, phone: props.phone, now }),
+            component(Header, { model, stale, phone: props.phone, now }),
             component(Queue, { model }),
             down,
+            model.schedules !== undefined && "status" in model.schedules
+                ? element("p", { class: "meta", children: "Schedules: unavailable" })
+                : null,
             component(RefusedWorkflows, { model }),
-            component(StartRun, {
-                workflows: model.workflows,
-                copying,
-                shown: start.shown,
-            }),
             component(WorkflowList, {
                 workflows: model.workflows,
                 selected: workflowId,

package/dist/src/cli.js

@@ -1,6 +1,8 @@
 #!/usr/bin/env node
 import { createProbeRunner } from "./cli/probe-command.js";
+import { terminateHarness } from "./cli/harness-processes.js";
 import { settingsEnvironment } from "./cli/project-settings.js";
+import { constants as systemConstants } from "node:os";
 import { addAbortListener } from "node:events";
 import { execFile, execFileSync, spawn } from "node:child_process";
 import { existsSync, realpathSync } from "node:fs";
@@ -30,7 +32,7 @@ const watchCommand = async (request) => {
         cwd: request.directory,
         signal: request.signal,
         killSignal: "SIGKILL",
-        maxBuffer: 1024 * 1024,
+        maxBuffer: request.outputBytes ?? 1024 * 1024,
         encoding: "utf8",
     }, (error, stdout) => {
         const code = error === null ? 0 : error.code;
@@ -58,6 +60,45 @@ const watchCommand = async (request) => {
         listener[Symbol.dispose]();
     }
 };
+function startHarness(request) {
+    return new Promise((settle) => {
+        try {
+            const child = spawn(request.executable, request.arguments, {
+                cwd: request.directory,
+                env: request.environment,
+                stdio: "inherit",
+            });
+            const interrupt = () => undefined;
+            const terminate = () => {
+                terminateHarness(child.pid, {
+                    snapshot: () => execFileSync("/bin/ps", ["-axo", "pid=,ppid="], {
+                        encoding: "utf8",
+                        timeout: 1000,
+                    }),
+                    kill: (identifier, signal) => process.kill(identifier, signal),
+                });
+            };
+            const cleanup = () => {
+                process.off("SIGINT", interrupt);
+                process.off("SIGTERM", terminate);
+            };
+            process.on("SIGINT", interrupt);
+            process.on("SIGTERM", terminate);
+            child.once("error", () => {
+                cleanup();
+                settle(null);
+            });
+            child.once("close", (status, signal) => {
+                cleanup();
+                settle(status ??
+                    (signal === null ? 1 : 128 + systemConstants.signals[signal]));
+            });
+        }
+        catch {
+            settle(null);
+        }
+    });
+}
 function startArguments(input) {
     const { runtime, repository, argumentsList } = input;
     const located = [
@@ -82,7 +123,10 @@ function startArguments(input) {
 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",
+        detached: input.tool === "red-green-command",
+        stdio: input.tool === "red-green-command"
+            ? ["inherit", "inherit", "inherit", "ipc"]
+            : "inherit",
         env: {
             ...process.env,
             PATH: [dirname(process.execPath), process.env["PATH"]].join(delimiter),
@@ -101,9 +145,13 @@ function toolProcess(input) {
     process.on("SIGTERM", terminate);
     return new Promise((settle) => {
         child.once("close", (status) => {
-            process.off("SIGINT", interrupt);
-            process.off("SIGTERM", terminate);
-            settle(stopping && status === 75 ? 0 : (status ?? 1));
+            setImmediate(() => {
+                setImmediate(() => {
+                    process.off("SIGINT", interrupt);
+                    process.off("SIGTERM", terminate);
+                    settle(stopping && status === 75 ? 0 : (status ?? 1));
+                });
+            });
         });
     });
 }
@@ -160,6 +208,11 @@ else if (command === "templates")
         tool: "template-command",
         argumentsList: options,
     });
+else if (command === "red-green")
+    process.exitCode = await toolProcess({
+        tool: "red-green-command",
+        argumentsList: options,
+    });
 else if (command === "start")
     process.exitCode = await start();
 else {
@@ -174,6 +227,7 @@ else {
     await main(process.argv.slice(2), {
         repository,
         environment,
+        startHarness,
         doctorProbe: createProbeRunner({
             spawn: (input) => spawn(input.executable, input.arguments, input.options),
             kill: (identifier, signal) => process.kill(identifier, signal),

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

@@ -0,0 +1,4 @@
+import type { HandoffValue, CommandWaitRequest } from "./step-bridge.ts";
+export type { CommandWaitRequest, CommandWaitOutcome, CommandWaitProgress, } from "./step-bridge.ts";
+export declare function isCommandWaitRequest(value: unknown): value is CommandWaitRequest;
+export declare function commandWaitValue(value: unknown, ancestors?: ReadonlySet<unknown>): value is HandoffValue;

package/dist/src/command-wait.js

@@ -0,0 +1,45 @@
+export function isCommandWaitRequest(value) {
+    if (!dataFields(value, ["name", "input"]))
+        return false;
+    const name = Reflect.get(value, "name");
+    return (typeof name === "string" &&
+        name.length > 0 &&
+        commandWaitValue(Reflect.get(value, "input")));
+}
+function dataFields(value, keys) {
+    if (value === null || typeof value !== "object" || Array.isArray(value))
+        return false;
+    return (Reflect.ownKeys(value).length === keys.length &&
+        keys.every((key) => {
+            const field = Object.getOwnPropertyDescriptor(value, key);
+            return field?.enumerable === true && Object.hasOwn(field, "value");
+        }));
+}
+export function commandWaitValue(value, ancestors = new Set()) {
+    if (value === null || typeof value === "string" || typeof value === "boolean")
+        return true;
+    if (typeof value === "number")
+        return Number.isFinite(value);
+    if (typeof value !== "object" || ancestors.has(value))
+        return false;
+    return commandWaitObject(value, ancestors);
+}
+function commandWaitObject(value, ancestors) {
+    const prototype = Object.getPrototypeOf(value);
+    const expectedPrototype = Object.getPrototypeOf(Array.isArray(value) ? [] : {});
+    if (prototype !== expectedPrototype && prototype !== null)
+        return false;
+    const keys = Array.isArray(value)
+        ? Array.from({ length: value.length }, (_, index) => String(index))
+        : Object.keys(value);
+    const ownKeys = Reflect.ownKeys(value).filter((key) => !Array.isArray(value) || key !== "length");
+    if (keys.length !== ownKeys.length)
+        return false;
+    const seen = new Set([...ancestors, value]);
+    return keys.every((key) => {
+        const field = Object.getOwnPropertyDescriptor(value, key);
+        return (field?.enumerable === true &&
+            Object.hasOwn(field, "value") &&
+            commandWaitValue(field.value, seen));
+    });
+}