cloving 0.3.19 → 1.0.1

package/dist/src/cli/usage.js

@@ -0,0 +1,124 @@
+const binding = "--expected-revision <n> --generation <n> --subject-digest <digest>";
+export const commandUsage = {
+    run: `Usage: cloving run <workflow-id> (--prompt <text> | --ticket <id> | --next | --input <json-file>) [--command-id <id>] [--json]
+
+Submits one run of an admitted workflow. Use exactly one input source.
+With --ticket, the workflow gets the ticket ID and reads the ticket itself.
+With --next (the same as --ticket next), develop-issue and develop-ticket select a ready ticket through CLOVING_NEXT_COMMAND.
+Success means a committed receipt. It does not mean completed work.
+`,
+    status: `Usage: cloving status [<run-id>] [--limit <n>] [--after <cursor>] [--json]
+
+Lists the runs, or shows one run with its reason, evidence and next action.
+`,
+    questions: `Usage: cloving questions [<run-id>] [--json]
+
+Lists the pending decisions with the values that a decision command needs.
+`,
+    answer: `Usage: cloving answer <decision-ref> --text <answer> ${binding} [--command-id <id>] [--json]
+
+Records an answer to one design question.
+`,
+    approve: `Usage: cloving approve <decision-ref> ${binding} [--command-id <id>] [--json]
+
+Approves one pending approval.
+`,
+    deny: `Usage: cloving deny <decision-ref> [--text <feedback>] ${binding} [--command-id <id>] [--json]
+
+Denies one pending approval. The workflow continues with the denial.
+A feedback text has at most 8000 bytes. The ticket workflow sends it to the next round.
+`,
+    pause: `Usage: cloving pause <run-id> --expected-revision <n> [--command-id <id>] [--json]
+
+Stops new dispatch for the run. Work in progress is not stopped at once.
+`,
+    resume: `Usage: cloving resume <run-id> --expected-revision <n> [--command-id <id>] [--json]
+
+Returns a paused run to the state that it paused from.
+`,
+    drop: `Usage: cloving drop <run-id> --expected-revision <n> [--command-id <id>] [--json]
+
+Cancels the run and its pending dispatch. It keeps the workspace and the evidence.
+`,
+    events: `Usage: cloving events [<run-id>] [--after <sequence>] [--limit <n>] [--follow] [--json]
+
+Prints the committed events after a sequence. With --json, each line is one event.
+`,
+    watch: `Usage: cloving watch [--port <n>]
+
+Serves a page on http://127.0.0.1:<port>/ that shows the runs live: the state,
+the events, the work of the Claude worker and each pending decision.
+The default port is 3663. The page is read only. Stop it with Control-C.
+`,
+    start: `Usage: cloving start [--repository <directory>]
+
+Starts the Cloving service for one git repository, with the workflow host,
+the Claude worker and the watch page. The default repository is the current
+directory. This command works in a development checkout of Cloving.
+Stop it with Control-C.
+
+The command reads these settings from the environment:
+  CLOVING_RUNTIME_DIR              The path of the runtime directory. The default is ~/.local/state/cloving/run, if XDG_RUNTIME_DIR and XDG_STATE_HOME are not set.
+  CLOVING_TICKET_COMMAND           A JSON list of a command and its arguments. The command gets a ticket ID as its last argument and prints the ticket. The setting has no default, and a run with --ticket needs it.
+  CLOVING_NOTIFY_COMMAND           A JSON list of a command and its arguments. Every 15 seconds, new decisions, blocked runs and failed runs send JSON on standard input with no added argument. The setting has no default.
+  CLOVING_NEXT_COMMAND             A JSON list of a command and its arguments. The command runs with no added argument and prints one ready ticket ID for --next. The setting has no default.
+  CLOVING_QUEUE_SECONDS            A whole number from 10 to 3600 seconds between develop-issue queue checks; requires CLOVING_NEXT_COMMAND and CLOVING_TICKET_COMMAND. Unset means no queue. The queue stops after a failed, cancelled or unsuccessful run until restart; manual develop-issue submissions are refused with workflow-active while an issue run is active.
+  CLOVING_SELF_UPDATE_SECONDS      A whole number from 30 to 3600 seconds between checks of the own checkout; unset means no update. An update stops the daemon and restarts with new code. A change of package-lock.json needs the operator to update and install by hand.
+  CLOVING_CLAUDE_COMMAND           A JSON list of a command and its arguments for the Claude worker. The default is the claude command with a limit of 5 USD for each turn.
+  CLOVING_PROFILES                 The path of a JSON file of operator-defined Claude turn profiles, read once at start. The setting has no default.
+  CLOVING_WORKER                   The worker for each turn: claude or codex. The default is claude. Other values stop the start with invalid-worker.
+  CLOVING_CODEX_COMMAND            A JSON list of a command and its arguments, used only when CLOVING_WORKER is codex; CLOVING_CLAUDE_COMMAND is then ignored. The default is codex exec --json --dangerously-bypass-approvals-and-sandbox --skip-git-repo-check -, with no sandbox and no approval prompts.
+  CLOVING_WATCH_PORT               The port number of the watch page. The value off starts no watch page. The default is 3663.
+  CLOVING_OWNERSHIP_LEASE_SECONDS  The time in seconds of the ownership lease of a started workflow step. The default is 15.
+  CLOVING_HOST_BOUND               The largest number of queue messages that the workflow host handles at one time, from 1 to 64. The default is 8.
+  CLOVING_GH_COMMAND               A JSON list of a command and its arguments for the GitHub CLI, which the workflow develop-issue uses for pull requests and develop-prd uses for issues. The default is gh.
+  CLOVING_CHECK_COMMAND            A JSON list of a command and its arguments that the workflow develop-issue runs in the work tree before a merge. A merge does not occur if the command fails. The setting has no default, and with no setting the merge occurs with no check.
+  CLOVING_PRIVATE_TEXTS            A JSON list of texts that the workflow develop-issue does not push in a file or in a commit message. The workflow develop-prd requires the list before posting an issue. The list adds to the path of the home folder, and the case of the letters does not matter. The setting has no default.
+`,
+};
+export const usage = `Usage: cloving [--help] [--version]
+       cloving workflows validate <manifest-path> [--input <json-file>] [--json]
+       cloving <command> [--help]
+
+Commands:
+  workflows validate  Check a compiled workflow manifest, its artifacts and optional runtime input.
+  chats import  Import explicitly selected Claude Code transcripts into private runtime files.
+  run        Submit one run of an admitted workflow.
+  status     List the runs or show one run.
+  questions  List the pending decisions.
+  answer     Answer one design question.
+  approve    Approve one pending approval.
+  deny       Deny one pending approval.
+  pause      Stop new dispatch for a run.
+  resume     Resume a paused run.
+  drop       Cancel a run and keep its files.
+  events     Print the committed events.
+  watch      Serve a page that shows the runs live.
+  start      Start the service for a repository.
+
+The runtime commands need a Cloving service. CLOVING_RUNTIME_DIR names its runtime directory.
+Use npm exec -- cloving ... for a project-local installation.
+`;
+export const chatsImportUsage = `Usage: cloving chats import [--] <path> [<path> ...]
+
+Imports only the selected Claude Code JSONL files. Relative paths use the current directory.
+This local command needs no service. It does not expand globs or scan directories.
+The file limit is 10 MiB (10,485,760 bytes). Links and nonregular files are refused.
+Private corpus.jsonl and coverage.json files go into a new import directory under the runtime directory's chats directory.
+The runtime selection is CLOVING_RUNTIME_DIR, XDG_RUNTIME_DIR, XDG_STATE_HOME, then HOME.
+Output contains only counts, fixed codes and an opaque import ID. Source paths stay in the private manifest.
+Exit codes: 0 for complete coverage, 1 for refused sources or output failure, 2 for invalid usage.
+`;
+export const validateUsage = `Usage: cloving workflows validate <manifest-path> [--input <json-file>] [--json]
+
+Checks a Cloving workflow manifest, its compiled SDK artifacts, declared resources and toolchain, and an optional runtime input file. Relative paths resolve against the current directory.
+
+Options:
+  --input <json-file>  Validate this runtime input file.
+  --json               Print one versioned JSON result on stdout.
+
+Validation does not admit a run, dispatch effects, import workflow code or call a model.
+
+Example:
+  cloving workflows validate cloving.workflow.json --input input.json
+`;

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

@@ -0,0 +1,38 @@
+import { type ExecutionManifest } from "../workflow-admission.ts";
+export interface ValidationError {
+    readonly code: string;
+    readonly file: string;
+    readonly detail: string;
+}
+export type ValidationReport = {
+    readonly schemaVersion: 1;
+    readonly kind: "workflow-validation";
+    readonly status: "valid";
+    readonly workflow: {
+        readonly name: string;
+        readonly workflowId: string;
+    };
+    readonly pinnedIdentity: string;
+    readonly errors: readonly ValidationError[];
+} | {
+    readonly schemaVersion: 1;
+    readonly kind: "workflow-validation";
+    readonly status: "rejected";
+    readonly errors: readonly ValidationError[];
+};
+export type CompiledAdmission = {
+    readonly kind: "admitted";
+    readonly manifest: ExecutionManifest;
+} | {
+    readonly kind: "rejected";
+    readonly error: ValidationError;
+};
+export interface AdmissionRequest {
+    readonly file: string;
+    readonly capabilities: readonly string[];
+}
+export declare function validateWorkflow(directory: string, files: {
+    readonly manifest: string;
+    readonly input: string | null;
+}): Promise<ValidationReport>;
+export declare function admitCompiled(path: string, request: AdmissionRequest): Promise<CompiledAdmission>;

package/dist/src/cli/validate.js

@@ -0,0 +1,116 @@
+import { createHash } from "node:crypto";
+import { readFile } from "node:fs/promises";
+import { dirname, resolve } from "node:path";
+import { pinnedIdentity } from "../execution-pin.js";
+import { collectResources } from "../resource-files.js";
+import { admitWorkflow, } from "../workflow-admission.js";
+import { validateDevelopmentInput } from "../workflow-contracts.js";
+import { observedToolchain, qualifiedToolchain } from "./toolchain.js";
+const artifactNames = [
+    "client.mjs",
+    "flow.mjs",
+    "flow.mjs.__wf_tmp.js.debug.json",
+    "manifest.json",
+    "steps.mjs",
+    "steps.mjs.debug.json",
+];
+export async function validateWorkflow(directory, files) {
+    const { manifest, input } = files;
+    const errors = input === null ? [] : await inputErrors(resolve(directory, input), input);
+    const admission = await admitCompiled(resolve(directory, manifest), {
+        file: manifest,
+        capabilities: [],
+    });
+    if (admission.kind === "rejected")
+        errors.push(admission.error);
+    if (admission.kind === "rejected" || errors.length > 0)
+        return {
+            schemaVersion: 1,
+            kind: "workflow-validation",
+            status: "rejected",
+            errors,
+        };
+    return {
+        schemaVersion: 1,
+        kind: "workflow-validation",
+        status: "valid",
+        workflow: {
+            name: admission.manifest.name,
+            workflowId: admission.manifest.workflowId,
+        },
+        pinnedIdentity: createHash("sha256")
+            .update(pinnedIdentity(admission.manifest))
+            .digest("hex"),
+        errors: [],
+    };
+}
+async function inputErrors(path, file) {
+    const value = await readJson(path);
+    if (value === null)
+        return [{ code: "unreadable-input", file, detail: "json" }];
+    if (validateDevelopmentInput(value).kind === "valid")
+        return [];
+    return [{ code: "invalid-development-input", file, detail: "cycleId" }];
+}
+export async function admitCompiled(path, request) {
+    const { file, capabilities } = request;
+    const registration = fields(await readJson(path));
+    const artifacts = registration["artifacts"];
+    if (registration["schemaVersion"] !== 1 || typeof artifacts !== "string")
+        return rejected({
+            code: "invalid-manifest",
+            file,
+            detail: "schemaVersion or artifacts",
+        });
+    const root = dirname(path);
+    const directory = resolve(root, artifacts);
+    const digests = {};
+    const contents = {};
+    for (const name of artifactNames) {
+        const bytes = await readFile(resolve(directory, name)).catch(() => null);
+        if (bytes === null)
+            return rejected({ code: "missing-artifact", file, detail: name });
+        digests[name] = createHash("sha256").update(bytes).digest("hex");
+        contents[name] = bytes;
+    }
+    const declared = registration["resources"];
+    const toolchain = await observedToolchain(directory);
+    const result = admitWorkflow(registration, {
+        compiled: {
+            manifest: parseJson(contents["manifest.json"]?.toString("utf8") ?? ""),
+            artifacts: digests,
+            resources: await collectResources(root, Array.isArray(declared)
+                ? declared.filter((item) => typeof item === "string")
+                : []),
+            toolchain,
+        },
+        policy: {
+            toolchain: await qualifiedToolchain(toolchain, directory),
+            capabilities,
+        },
+    });
+    if (result.kind === "rejected")
+        return rejected({ code: result.reason, file, detail: result.detail });
+    return result;
+}
+function rejected(error) {
+    return { kind: "rejected", error };
+}
+async function readJson(path) {
+    const text = await readFile(path, "utf8").catch(() => null);
+    return text === null ? null : parseJson(text);
+}
+function parseJson(text) {
+    try {
+        const value = JSON.parse(text);
+        return value;
+    }
+    catch {
+        return null;
+    }
+}
+function fields(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        return {};
+    return Object.fromEntries(Object.entries(value));
+}

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

@@ -0,0 +1,22 @@
+import { type Shown } from "./watch-element.ts";
+import type { WatchCard, WatchWorkflow } from "./watch-render.ts";
+export declare function cardStep(card: WatchCard, now: string): string;
+export declare function cardReview(card: WatchCard): string;
+export declare function CardReview(props: {
+    readonly card: WatchCard;
+    readonly workflowId: string;
+}): Shown;
+export declare function completionMark(card: WatchCard, workflowId: string): Shown;
+export declare function Card(props: {
+    readonly card: WatchCard;
+    readonly workflowId: string;
+    readonly now: string;
+}): Shown;
+export declare function WorkflowList(props: {
+    readonly workflows: readonly WatchWorkflow[];
+    readonly selected: string | null;
+}): Shown;
+export declare function Board(props: {
+    readonly workflow: WatchWorkflow;
+    readonly now: string;
+}): Shown;

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

@@ -0,0 +1,128 @@
+import { component, element } from "./watch-element.js";
+import { watchHash } from "./watch-navigation.js";
+export function cardStep(card, now) {
+    if (card.endedAt !== null)
+        return new Date(card.endedAt).toLocaleString();
+    const step = card.currentStep;
+    if (step === null)
+        return "";
+    if (step.startedAt === null)
+        return step.name;
+    const minutes = Math.max(0, Math.floor((Date.parse(now) - Date.parse(step.startedAt)) / 60000));
+    return `${step.name} · ${String(minutes)} min`;
+}
+export function cardReview(card) {
+    return [
+        card.round === null ? null : `round ${String(card.round)}`,
+        card.greptileScore === null ? null : `${String(card.greptileScore)}/5`,
+        card.pullRequestNumber === null
+            ? null
+            : `#${String(card.pullRequestNumber)}`,
+    ]
+        .filter((part) => part !== null)
+        .join(" · ");
+}
+export function CardReview(props) {
+    if (props.workflowId !== "develop-issue")
+        return null;
+    const review = cardReview(props.card);
+    if (review === "")
+        return null;
+    return element("span", {
+        class: "card-review",
+        children: review
+            .split(" · ")
+            .map((part, index) => [
+            index === 0 ? "" : " · ",
+            element("span", { class: "review-pill", children: part }),
+        ]),
+    });
+}
+export function completionMark(card, workflowId) {
+    const mark = card.completionMark;
+    if (mark === null)
+        return null;
+    if (mark.laterRunId === null)
+        return element("span", { class: "completion-mark", children: mark.text });
+    return element("a", {
+        class: "completion-mark",
+        href: watchHash({ workflowId, runId: mark.laterRunId }),
+        children: mark.text,
+    });
+}
+export function Card(props) {
+    const { card, workflowId, now } = props;
+    return element("article", {
+        class: "card",
+        children: [
+            element("a", {
+                class: "card-run",
+                href: watchHash({ workflowId, runId: card.runId }),
+                children: [
+                    element("strong", { children: card.title ?? card.runId }),
+                    element("span", {
+                        class: card.endedAt === null && card.currentStep !== null
+                            ? "card-step active"
+                            : "card-step",
+                        children: cardStep(card, now),
+                    }),
+                    component(CardReview, { card, workflowId }),
+                    element("span", {
+                        class: "card-cost",
+                        children: `${card.claudeCostUsd.toFixed(2)} USD`,
+                    }),
+                    card.decisionWaiting
+                        ? element("span", {
+                            class: "decision-mark",
+                            children: "! Decision waiting",
+                        })
+                        : null,
+                    element("small", { children: card.runId }),
+                ],
+            }),
+            completionMark(card, workflowId),
+        ],
+    });
+}
+export function WorkflowList(props) {
+    return element("nav", {
+        class: "workflows",
+        "aria-label": "Workflows",
+        children: props.workflows.map((workflow) => element("a", {
+            key: workflow.workflowId,
+            href: watchHash({ workflowId: workflow.workflowId, runId: null }),
+            "aria-current": workflow.workflowId === props.selected ? "page" : undefined,
+            children: [
+                element("strong", { children: workflow.workflowId }),
+                element("span", {
+                    children: `${String(workflow.activeCount)} active · ${String(workflow.waitingCount)} waiting`,
+                }),
+            ],
+        })),
+    });
+}
+export function Board(props) {
+    const { workflow, now } = props;
+    return element("main", {
+        class: "board",
+        children: [
+            element("h2", { children: workflow.workflowId }),
+            element("div", {
+                class: "columns",
+                children: workflow.columns.map((column) => element("section", {
+                    key: column.name,
+                    class: column.name === "Stopped" ? "column stopped" : "column",
+                    children: [
+                        element("h3", { class: "column-name", children: column.name }),
+                        column.cards.map((card) => component(Card, {
+                            key: card.runId,
+                            card,
+                            workflowId: workflow.workflowId,
+                            now,
+                        })),
+                    ],
+                })),
+            }),
+        ],
+    });
+}

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

@@ -0,0 +1,15 @@
+import type { WatchCompletionMark, WatchRun, WatchStep, WatchWorkflow } from "./watch-render.ts";
+export declare function completionMarkOf(run: WatchRun, candidates: readonly WatchRun[]): WatchCompletionMark | null;
+export declare function activeRun(state: string): boolean;
+export declare function recentRun(latestAt: string | null, now: string): boolean;
+export declare function currentStepOf(events: readonly unknown[], workflowId: string): WatchStep;
+export declare function roundOf(events: readonly unknown[]): number;
+interface BoardInputs {
+    readonly workflows: readonly string[];
+    readonly updatedAt: string;
+    readonly summaries?: readonly unknown[];
+    readonly completionCandidates?: readonly WatchRun[];
+}
+export declare function boardsOf(inputs: BoardInputs, runs: readonly WatchRun[]): WatchWorkflow[];
+export declare function startWorkflowOf(workflows: readonly WatchWorkflow[]): string | null;
+export {};

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

@@ -0,0 +1,174 @@
+import { record } from "../protocol.js";
+import { isInstant } from "../authority/instants.js";
+import { issueSteps } from "./watch-phases.js";
+const weekMilliseconds = 7 * 24 * 60 * 60 * 1000;
+const terminalStates = ["completed", "failed", "cancelled"];
+function eventTime(run, type) {
+    const recordedAt = run.events.find((event) => event.type === type)?.recordedAt;
+    return isInstant(recordedAt) ? Date.parse(recordedAt) : NaN;
+}
+export function completionMarkOf(run, candidates) {
+    if (run.workflowId !== "develop-issue" ||
+        run.state !== "completed" ||
+        run.outcome !== "blocked")
+        return null;
+    const completedAt = eventTime(run, "run.completed");
+    const later = candidates
+        .filter((candidate) => typeof run.ticketId === "string" &&
+        run.ticketId !== "" &&
+        candidate.ticketId === run.ticketId &&
+        candidate.runId !== run.runId &&
+        candidate.workflowId === "develop-issue" &&
+        candidate.state === "completed" &&
+        candidate.outcome === "handoff_requested")
+        .map((candidate) => ({
+        runId: candidate.runId,
+        createdAt: eventTime(candidate, "run.created"),
+    }))
+        .filter((candidate) => candidate.createdAt > completedAt)
+        .toSorted((first, second) => first.createdAt - second.createdAt ||
+        (first.runId < second.runId ? -1 : 1))[0];
+    return later === undefined
+        ? { text: "Needs attention", laterRunId: null }
+        : { text: "Done in a later run", laterRunId: later.runId };
+}
+export function activeRun(state) {
+    return !terminalStates.includes(state);
+}
+export function recentRun(latestAt, now) {
+    const age = Date.parse(now) - Date.parse(latestAt ?? "");
+    return age >= 0 && age <= weekMilliseconds;
+}
+function stepNames(workflowId) {
+    return workflowId === "develop-issue"
+        ? issueSteps.map((step) => step.name)
+        : ["Claude turn", "Your review"];
+}
+function operationOf(event) {
+    const payload = record(record(event)?.["payload"]);
+    try {
+        const operation = JSON.parse(String(payload?.["operationId"]));
+        return Array.isArray(operation) ? operation : [];
+    }
+    catch {
+        return [];
+    }
+}
+function stepName(event, workflowId) {
+    const type = record(event)?.["type"];
+    if (workflowId !== "develop-issue" && type === "gate.opened")
+        return "Your review";
+    if (type !== "effect.requested")
+        return undefined;
+    if (workflowId !== "develop-issue")
+        return "Claude turn";
+    return issueSteps.find((step) => step.operation === operationOf(event)[4])
+        ?.name;
+}
+function startedAt(event) {
+    const value = record(event)?.["recordedAt"];
+    return typeof value === "string" ? value : null;
+}
+function chronological(events) {
+    return events.toSorted((first, second) => Date.parse(startedAt(first) ?? "") - Date.parse(startedAt(second) ?? ""));
+}
+export function currentStepOf(events, workflowId) {
+    const event = chronological(events).findLast((item) => stepName(item, workflowId) !== undefined);
+    return {
+        name: stepName(event, workflowId) ?? stepNames(workflowId)[0] ?? "Claude turn",
+        startedAt: startedAt(event),
+    };
+}
+export function roundOf(events) {
+    const event = chronological(events).findLast((item) => record(item)?.["type"] === "effect.requested" &&
+        operationOf(item)[4] === "claude-turn");
+    const round = operationOf(event)[1];
+    return typeof round === "number" ? round : 1;
+}
+function columnOf(run, now) {
+    if (activeRun(run.state))
+        return run.currentStep.name;
+    if (!recentRun(run.latestAt, now))
+        return null;
+    if (run.state !== "completed" || run.outcome === "blocked")
+        return "Stopped";
+    return run.outcome === "handoff_requested" ? "Done" : null;
+}
+function cardOf(run, runs) {
+    const issue = run.workflowId === "develop-issue";
+    return {
+        runId: run.runId,
+        title: run.title,
+        completionMark: completionMarkOf(run, runs),
+        claudeCostUsd: run.claudeCostUsd,
+        currentStep: activeRun(run.state) ? run.currentStep : null,
+        endedAt: activeRun(run.state) ? null : run.latestAt,
+        decisionWaiting: run.decisions.length > 0,
+        round: issue ? run.round : null,
+        greptileScore: issue ? (run.reviews.at(-1)?.score ?? null) : null,
+        pullRequestNumber: issue ? (run.pullRequest?.number ?? null) : null,
+    };
+}
+function stepOrder(first, second) {
+    const waiting = Number(second.decisionWaiting) - Number(first.decisionWaiting);
+    if (waiting !== 0)
+        return waiting;
+    return (Date.parse(first.currentStep?.startedAt ?? "1970-01-01") -
+        Date.parse(second.currentStep?.startedAt ?? "1970-01-01"));
+}
+function latestTime(times) {
+    return (times
+        .filter((time) => time !== null)
+        .toSorted((first, second) => Date.parse(second) - Date.parse(first))[0] ??
+        null);
+}
+function summaryOf(value) {
+    const fields = record(value);
+    const pending = fields?.["pendingDecisions"];
+    const latest = fields?.["latestAt"];
+    return {
+        state: String(fields?.["state"]),
+        waiting: Array.isArray(pending) && pending.length > 0,
+        latestAt: typeof latest === "string" ? latest : null,
+    };
+}
+export function boardsOf(inputs, runs) {
+    return inputs.workflows.map((workflowId) => {
+        const own = runs.filter((run) => run.workflowId === workflowId);
+        const summaries = inputs.summaries === undefined
+            ? own.map((run) => ({
+                state: run.state,
+                waiting: run.decisions.length > 0,
+                latestAt: run.latestAt,
+            }))
+            : inputs.summaries
+                .filter((value) => record(value)?.["workflowId"] === workflowId)
+                .map(summaryOf);
+        const columns = [...stepNames(workflowId), "Done", "Stopped"].map((name) => {
+            const cards = own
+                .filter((run) => columnOf(run, inputs.updatedAt) === name)
+                .map((run) => cardOf(run, inputs.completionCandidates ?? runs));
+            return {
+                name,
+                cards: ["Done", "Stopped"].includes(name)
+                    ? cards
+                        .toSorted((first, second) => Date.parse(second.endedAt ?? "") -
+                        Date.parse(first.endedAt ?? ""))
+                        .slice(0, 20)
+                    : cards.toSorted(stepOrder),
+            };
+        });
+        return {
+            workflowId,
+            activeCount: summaries.filter((run) => activeRun(run.state)).length,
+            waitingCount: summaries.filter((run) => run.waiting).length,
+            latestAt: latestTime(summaries.map((run) => run.latestAt)),
+            columns,
+        };
+    });
+}
+export function startWorkflowOf(workflows) {
+    const waiting = workflows.filter((workflow) => workflow.waitingCount > 0);
+    return ((waiting.length > 0 ? waiting : workflows).toSorted((first, second) => Date.parse(second.latestAt ?? "1970-01-01") -
+        Date.parse(first.latestAt ?? "1970-01-01"))[0]?.workflowId ?? null);
+}

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

@@ -0,0 +1,11 @@
+export type WatchElement = {
+    readonly tag: string;
+    readonly props: Readonly<Record<string, unknown>>;
+} | {
+    readonly content: () => Shown;
+};
+export type Shown = WatchElement | string | number | null | undefined | readonly Shown[];
+export declare function element(tag: string, props: Readonly<Record<string, unknown>>): WatchElement;
+export declare function component<Props>(type: (props: Props) => Shown, props: Props & {
+    readonly key?: string;
+}): WatchElement;

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

@@ -0,0 +1,6 @@
+export function element(tag, props) {
+    return { tag, props };
+}
+export function component(type, props) {
+    return { content: () => type(props) };
+}

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

@@ -0,0 +1,29 @@
+import type { WatchDecision, WatchItem, WatchModel, WatchTurn } from "./watch-render.ts";
+export declare function activityOf(line: string): WatchItem[];
+export interface TurnRecords {
+    readonly key: string;
+    readonly started: unknown;
+    readonly result: unknown;
+    readonly lines: readonly string[];
+    readonly activeAt?: string | null;
+}
+export declare function turnOf(records: TurnRecords): WatchTurn;
+export declare function decisionCommands(decision: unknown, client: string): WatchDecision;
+export interface WatchInputs {
+    readonly workflows: readonly string[];
+    readonly summaries?: readonly unknown[];
+    readonly home: string;
+    readonly client: string;
+    readonly updatedAt: string;
+    readonly service: string;
+    readonly runs: readonly unknown[];
+    readonly completionCandidates?: readonly unknown[];
+    readonly decisions: readonly unknown[];
+    readonly turns: readonly WatchTurn[];
+    readonly githubRecords: readonly GithubRecords[];
+}
+export interface GithubRecords {
+    readonly started: unknown;
+    readonly result: unknown;
+}
+export declare function watchModel(inputs: WatchInputs): WatchModel;