cloving 1.0.1 → 1.2.0

package/dist/src/cli/usage.js

@@ -50,29 +50,40 @@ 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>]
+    start: `Usage: cloving start [--repository <directory>] [--reset-queue]
 
 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 queue continues after unsuccessful runs and stops after three runs in a row
+without a successful handoff. A successful handoff resets the count; ordinary restarts preserve the count.
+Stop the service, inspect the failures and reconcile affected issues, then start with --reset-queue and the same queue settings to clear the failure streak once. Tracked commands are preserved.
+
 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_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. It must exclude the space-separated ticket IDs in CLOVING_SKIP_TICKETS. 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 three runs in a row without a successful handoff; manual develop-issue submissions are refused with workflow-active when all lanes are busy.
+  CLOVING_QUEUE_LANES              A whole number from 1 to 4; the default is 1. Requires CLOVING_QUEUE_SECONDS. Active tickets are refused with ticket-active. Needs #N sentences in the ticket's ## Dependencies section refuse admission with ticket-dependency-open while issue #N is open.
   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_ANALYSIS_TOKEN_COMMAND   A JSON list of a program and its nonempty string arguments, run without a shell just before analysis. It has limits of 10 seconds and 4096 combined stdout/stderr bytes; stdout must be one printable ASCII token without spaces, at most 512 bytes after one final line break. Only analysis receives CLAUDE_CODE_OAUTH_TOKEN; API keys are excluded. There is no default.
   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_TOKEN_PRICES             A JSON object from model names to input, cachedInput and output USD prices per million tokens for estimates; entries override matching built-in prices.
+  CLOVING_FALLBACK_MODELS          A JSON array of at most three nonempty model names; the default is no fallback. After capacity refusals the first retry keeps the main model and the third attempt uses the first fallback, with the same waits and attempt limit. Requires an explicit -m, --model or --model= argument; does not change analyze-chats analysis. A fallback can have a higher price.
   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_REPOSITORY         The service repository context for the watch board, set by start from --repository. Its local origin supplies the GitHub identity. There is no current-directory default.
+  CLOVING_WATCH_ACTIONS            The value off removes the board run form and its write endpoint. The default is on.
   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_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 watch board also uses it to read pull request status. 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_REQUIRED_CHECKS          A JSON list of required check run names before a develop-issue merge. Unset requires all GitHub Actions checks; a repository with no CI can merge after 60 seconds. The latest run of each name decides. The CI wait limit is 90 minutes.
   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.
 `,
 };
@@ -82,6 +93,7 @@ export const usage = `Usage: cloving [--help] [--version]
 
 Commands:
   workflows validate  Check a compiled workflow manifest, its artifacts and optional runtime input.
+  chats redact  Redact one imported chat corpus into private runtime files.
   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.
@@ -100,14 +112,29 @@ The runtime commands need a Cloving service. CLOVING_RUNTIME_DIR names its runti
 Use npm exec -- cloving ... for a project-local installation.
 `;
 export const chatsImportUsage = `Usage: cloving chats import [--] <path> [<path> ...]
+       cloving chats import --root <projects-folder> [--root <projects-folder> ...] [--exclude-project <name> ...] [-- <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.
+This local command needs no service. It scans only explicitly named roots and does not expand globs or discover configuration.
+Positional files come first, retaining order and repetitions. Roots sort by canonical path, then entries by relative path in JavaScript string order.
+Exclusions match direct project folder names exactly and prune their children. Exclusions require a root.
+Scans accept lowercase .jsonl filenames, attempt at most 100 eligible files across roots, and stop before entering folders at depth four.
+Later file candidates and depth-limited folders are pending. Select pending files explicitly in a later import.
+Linked components, containment changes and roots in Git repositories are refused. Scan protections require the supported macOS kernel.
 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 total normalized corpus limit is 50 MiB (52,428,800 UTF-8 bytes), including newlines and repeated selections.
+Exceeding that total returns output-failed with exit code 1 and no completed coverage manifest; partial files may remain.
+--previous-import <IMPORT_ID> compares against one explicitly named UUID v4 import before --.
+The earlier coverage and optional revision must be valid, completed private metadata; otherwise previous-import-refused returns exit 1 with no new import.
+A comparison writes private revision.json with ordered selection evidence and six status counts. Matching uses source path and selected root path; repetitions pair in order.
+Byte-verified extensions are extended; shorter sources are truncated. Legacy imports without sizes can establish unchanged digests but cannot prove extension or truncation.
+Missing or truncated evidence makes the import partial. History completeness remains unknown.
+Private corpus.jsonl, structure.json 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.
+Structure preserves branches and marks known copies without removing records. History completeness remains unknown.
+Root imports write coverage version 2 and add excluded and pending entry counts; positional-only imports retain coverage version 1.
+Exit codes: 0 for no refused, pending, missing or truncated entries (exclusions alone permit success without comparison), 1 for partial coverage or processing failure, 2 for invalid usage.
 `;
 export const validateUsage = `Usage: cloving workflows validate <manifest-path> [--input <json-file>] [--json]
 
@@ -122,3 +149,11 @@ Validation does not admit a run, dispatch effects, import workflow code or call
 Example:
   cloving workflows validate cloving.workflow.json --input input.json
 `;
+export const chatsRedactUsage = `Usage: cloving chats redact <IMPORT_ID>
+
+Redact one existing import selected by its UUID v4 import ID. No service is required.
+Write redacted.jsonl and redaction.json beside the original corpus with mode 0600.
+HOME supplies the home folder. CLOVING_PRIVATE_TEXTS is an optional JSON list of nonblank strings.
+Originals and metadata remain private. Redaction does not authorize model use or guarantee removal of every private value.
+Exit codes: 0 complete, 1 processing failure, 2 invalid usage.
+`;

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

@@ -0,0 +1,10 @@
+import type { IncomingMessage } from "node:http";
+import { type CardForm } from "./watch-run-input.ts";
+export interface WatchActions {
+    readonly forms: readonly CardForm[];
+    readonly token: string;
+    readonly runtimeDirectory: string;
+}
+export declare function watchActions(runtimeDirectory: string): Promise<WatchActions>;
+export declare function watchHost(request: IncomingMessage): boolean;
+export declare function watchAction(actions: WatchActions, request: IncomingMessage): Promise<string | null>;

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

@@ -0,0 +1,58 @@
+import { randomBytes } from "node:crypto";
+import { send } from "./client.js";
+import { watchCardForms } from "./watch-card-forms.js";
+import { join } from "node:path";
+import { cardRunRequest } from "./watch-run-input.js";
+export async function watchActions(runtimeDirectory) {
+    return {
+        runtimeDirectory,
+        forms: await watchCardForms(join(import.meta.dirname, "../../workflows")),
+        token: randomBytes(32).toString("hex"),
+    };
+}
+export function watchHost(request) {
+    const port = request.socket.localPort;
+    return [`127.0.0.1:${String(port)}`, `localhost:${String(port)}`].includes(request.headers.host ?? "");
+}
+function authorized(actions, request) {
+    return (watchHost(request) &&
+        request.headers.origin === `http://${request.headers.host ?? ""}` &&
+        request.headers["x-cloving-token"] === actions.token &&
+        /^application\/json(?:\s*;\s*charset=utf-8)?$/i.test(request.headers["content-type"] ?? ""));
+}
+async function bodyOf(request) {
+    const chunks = [];
+    let size = 0;
+    for await (const chunk of request) {
+        const bytes = Buffer.isBuffer(chunk) ? chunk : Buffer.from(String(chunk));
+        size += bytes.length;
+        if (size > 16384)
+            return null;
+        chunks.push(bytes);
+    }
+    try {
+        const value = JSON.parse(Buffer.concat(chunks).toString("utf8"));
+        return value;
+    }
+    catch {
+        return null;
+    }
+}
+export async function watchAction(actions, request) {
+    if (!authorized(actions, request))
+        return null;
+    const given = cardRunRequest(actions.forms, await bodyOf(request));
+    if (given === null)
+        return null;
+    const status = await send(actions.runtimeDirectory, {
+        operation: "status",
+        parameters: {},
+    });
+    if (status.kind === "error")
+        return JSON.stringify(status);
+    const workflows = status.result["workflows"];
+    if (!Array.isArray(workflows) ||
+        !workflows.includes(given.parameters["workflowId"]))
+        return null;
+    return JSON.stringify(await send(actions.runtimeDirectory, given));
+}

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

@@ -1,22 +1,65 @@
+import { type CardControls } from "./watch-card-view.ts";
+import type { CardForm } from "./watch-run-input.ts";
 import { type Shown } from "./watch-element.ts";
 import type { WatchCard, WatchWorkflow } from "./watch-render.ts";
+export declare const boardSizing: {
+    minimumColumnWidth: number;
+    collapsedColumnWidth: number;
+    gap: number;
+};
+export declare function boardLayout(input: {
+    readonly contentWidth: number;
+    readonly openColumns: number;
+    readonly collapsedColumns: number;
+}): {
+    readonly columnWidth: number;
+    readonly totalWidth: number;
+};
 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 staleObservation(card: WatchCard, now: string): Shown;
+export declare function observationText(card: WatchCard, fallback: string): string;
+export declare function completionMark(card: WatchCard, context: {
+    readonly workflowId: string;
+    readonly now: string;
+}): Shown;
 export declare function Card(props: {
     readonly card: WatchCard;
     readonly workflowId: string;
     readonly now: string;
+    readonly observationNow?: string | undefined;
+}): Shown;
+export declare function HandoffLinks(props: {
+    readonly run: Pick<WatchCard, "parentRunId" | "childRunIds">;
 }): Shown;
 export declare function WorkflowList(props: {
     readonly workflows: readonly WatchWorkflow[];
     readonly selected: string | null;
 }): Shown;
+export interface ColumnControls {
+    readonly choices: Readonly<Record<string, boolean>> | null;
+    readonly onToggle: (name: string) => void;
+    readonly onHover?: (name: string | null) => void;
+    readonly onFocus?: (name: string | null) => void;
+}
+export declare function columnCollapsed(choices: Readonly<Record<string, boolean>> | null, name: string): boolean;
+export declare function Column(props: {
+    readonly column: WatchWorkflow["columns"][number];
+    readonly addCard?: Shown;
+    readonly workflowId: string;
+    readonly now: string;
+    readonly observationNow?: string | undefined;
+    readonly controls?: ColumnControls | undefined;
+}): Shown;
 export declare function Board(props: {
     readonly workflow: WatchWorkflow;
+    readonly cardForm?: CardForm | undefined;
+    readonly cards?: CardControls | undefined;
     readonly now: string;
+    readonly observationNow?: string | undefined;
+    readonly controls?: ColumnControls | undefined;
 }): Shown;

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

@@ -1,5 +1,22 @@
+import { AddCard } from "./watch-card-view.js";
+import { priceText } from "./usage-render.js";
 import { component, element } from "./watch-element.js";
 import { watchHash } from "./watch-navigation.js";
+export const boardSizing = {
+    minimumColumnWidth: 200,
+    collapsedColumnWidth: 44,
+    gap: 12,
+};
+export function boardLayout(input) {
+    const { contentWidth, openColumns, collapsedColumns } = input;
+    const fixedWidth = collapsedColumns * boardSizing.collapsedColumnWidth +
+        Math.max(0, openColumns + collapsedColumns - 1) * boardSizing.gap;
+    const columnWidth = Math.max(boardSizing.minimumColumnWidth, (contentWidth - fixedWidth) / Math.max(1, openColumns));
+    return {
+        columnWidth: openColumns === 0 ? boardSizing.minimumColumnWidth : columnWidth,
+        totalWidth: openColumns * columnWidth + fixedWidth,
+    };
+}
 export function cardStep(card, now) {
     if (card.endedAt !== null)
         return new Date(card.endedAt).toLocaleString();
@@ -38,15 +55,45 @@ export function CardReview(props) {
         ]),
     });
 }
-export function completionMark(card, workflowId) {
+export function staleObservation(card, now) {
+    const observation = card.pullRequestObservation;
+    const lastSuccess = observation?.lastSuccess;
+    if (observation?.status === "merged" ||
+        lastSuccess?.status !== "unmerged" ||
+        !(Date.parse(now) - lastSuccess.readAt > 120000))
+        return null;
+    return [
+        " ",
+        element("span", { class: "completion-stale", children: "Stale" }),
+    ];
+}
+export function observationText(card, fallback) {
+    if (fallback !== "Needs attention")
+        return fallback;
+    const status = card.pullRequestObservation?.status;
+    if (status === "merged")
+        return `PR merged · #${String(card.pullRequestNumber)}`;
+    if (status === "pending")
+        return "Checking PR";
+    if (status === "unavailable")
+        return "PR status unavailable";
+    return fallback;
+}
+export function completionMark(card, context) {
     const mark = card.completionMark;
     if (mark === null)
         return null;
+    const text = observationText(card, mark.text);
     if (mark.laterRunId === null)
-        return element("span", { class: "completion-mark", children: mark.text });
+        return [
+            element("span", { class: "completion-mark", children: text }),
+            mark.text === "Needs attention"
+                ? staleObservation(card, context.now)
+                : null,
+        ];
     return element("a", {
         class: "completion-mark",
-        href: watchHash({ workflowId, runId: mark.laterRunId }),
+        href: watchHash({ workflowId: context.workflowId, runId: mark.laterRunId }),
         children: mark.text,
     });
 }
@@ -58,8 +105,11 @@ export function Card(props) {
             element("a", {
                 class: "card-run",
                 href: watchHash({ workflowId, runId: card.runId }),
+                title: card.runId,
                 children: [
-                    element("strong", { children: card.title ?? card.runId }),
+                    element("strong", {
+                        children: card.title ?? card.runId.slice(0, 12),
+                    }),
                     element("span", {
                         class: card.endedAt === null && card.currentStep !== null
                             ? "card-step active"
@@ -69,7 +119,7 @@ export function Card(props) {
                     component(CardReview, { card, workflowId }),
                     element("span", {
                         class: "card-cost",
-                        children: `${card.claudeCostUsd.toFixed(2)} USD`,
+                        children: `${card.currentStep === null ? "Totals" : "Totals so far"} · ${priceText(card.claudeCostUsd, card.estimatedCostUsd)}`,
                     }),
                     card.decisionWaiting
                         ? element("span", {
@@ -77,13 +127,28 @@ export function Card(props) {
                             children: "! Decision waiting",
                         })
                         : null,
-                    element("small", { children: card.runId }),
+                    element("small", { children: card.runId.slice(0, 12) }),
                 ],
             }),
-            completionMark(card, workflowId),
+            completionMark(card, { workflowId, now: props.observationNow ?? now }),
+            component(HandoffLinks, { run: card }),
         ],
     });
 }
+export function HandoffLinks(props) {
+    const { parentRunId, childRunIds } = props.run;
+    const links = [
+        ...(parentRunId == null
+            ? []
+            : [{ label: "Parent run", runId: parentRunId }]),
+        ...(childRunIds ?? []).map((runId) => ({ label: "Child run", runId })),
+    ];
+    return links.map(({ label, runId }) => element("a", {
+        class: "meta",
+        href: watchHash({ workflowId: null, runId }),
+        children: `${label}: ${runId}`,
+    }));
+}
 export function WorkflowList(props) {
     return element("nav", {
         class: "workflows",
@@ -101,6 +166,59 @@ export function WorkflowList(props) {
         })),
     });
 }
+export function columnCollapsed(choices, name) {
+    const value = choices !== null && Object.hasOwn(choices, name)
+        ? choices[name]
+        : undefined;
+    return value ?? ["Done", "Stopped"].includes(name);
+}
+export function Column(props) {
+    const { column, workflowId, now, controls } = props;
+    const collapsed = columnCollapsed(controls?.choices ?? null, column.name);
+    const tone = column.name === "Stopped" ? "column stopped" : "column";
+    return element("section", {
+        class: `${tone}${collapsed ? " collapsed" : ""}`,
+        onMouseEnter: () => controls?.onHover?.(column.name),
+        onMouseLeave: () => controls?.onHover?.(null),
+        onFocusIn: () => controls?.onFocus?.(column.name),
+        onFocusOut: () => controls?.onFocus?.(null),
+        children: [
+            element("h3", {
+                class: "column-name",
+                children: [
+                    element("span", { children: column.name }),
+                    " ",
+                    element("span", {
+                        class: "column-count",
+                        children: String(column.cards.length),
+                    }),
+                    element("button", {
+                        type: "button",
+                        "aria-label": `${collapsed ? "Expand" : "Collapse"} ${column.name}`,
+                        "aria-expanded": String(!collapsed),
+                        onClick: () => controls?.onToggle(column.name),
+                        children: collapsed ? "+" : "−",
+                    }),
+                ],
+            }),
+            collapsed
+                ? null
+                : element("div", {
+                    class: "column-cards",
+                    children: [
+                        column.cards.map((card) => component(Card, {
+                            key: card.runId,
+                            card,
+                            workflowId,
+                            now,
+                            observationNow: props.observationNow,
+                        })),
+                        props.addCard,
+                    ],
+                }),
+        ],
+    });
+}
 export function Board(props) {
     const { workflow, now } = props;
     return element("main", {
@@ -109,18 +227,19 @@ export function Board(props) {
             element("h2", { children: workflow.workflowId }),
             element("div", {
                 class: "columns",
-                children: workflow.columns.map((column) => element("section", {
+                children: workflow.columns.map((column, index) => component(Column, {
                     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,
-                        })),
-                    ],
+                    column,
+                    workflowId: workflow.workflowId,
+                    now,
+                    observationNow: props.observationNow,
+                    controls: props.controls,
+                    addCard: index === 0
+                        ? component(AddCard, {
+                            form: props.cardForm,
+                            controls: props.cards,
+                        })
+                        : null,
                 })),
             }),
         ],

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

@@ -1,11 +1,17 @@
+import type { WorkflowStage, WorkflowStages } from "../workflow-declaration.ts";
 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 stagesFor(metadata: WorkflowStages | undefined, workflowId: string): readonly WorkflowStage[] | undefined;
+export declare function currentStepOf(events: readonly unknown[], workflow: {
+    readonly workflowId: string;
+    readonly stages: readonly WorkflowStage[] | undefined;
+}): WatchStep;
 export declare function roundOf(events: readonly unknown[]): number;
 interface BoardInputs {
     readonly workflows: readonly string[];
+    readonly workflowStages?: WorkflowStages;
     readonly updatedAt: string;
     readonly summaries?: readonly unknown[];
     readonly completionCandidates?: readonly WatchRun[];

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

@@ -1,6 +1,8 @@
+import { linksOf } from "../authority/handoff-chain.js";
 import { record } from "../protocol.js";
 import { isInstant } from "../authority/instants.js";
 import { issueSteps } from "./watch-phases.js";
+import { sameIssue } from "./watch-pr-identity.js";
 const weekMilliseconds = 7 * 24 * 60 * 60 * 1000;
 const terminalStates = ["completed", "failed", "cancelled"];
 function eventTime(run, type) {
@@ -12,15 +14,21 @@ export function completionMarkOf(run, candidates) {
         run.state !== "completed" ||
         run.outcome !== "blocked")
         return null;
+    if (run.mergeProof != null)
+        return {
+            text: `PR merged · #${String(run.mergeProof.number)}`,
+            laterRunId: null,
+        };
     const completedAt = eventTime(run, "run.completed");
     const later = candidates
-        .filter((candidate) => typeof run.ticketId === "string" &&
-        run.ticketId !== "" &&
-        candidate.ticketId === run.ticketId &&
+        .filter((candidate) => sameIssue(run.issueIdentity, candidate.issueIdentity) &&
+        candidate.mergeProof != null &&
         candidate.runId !== run.runId &&
         candidate.workflowId === "develop-issue" &&
         candidate.state === "completed" &&
-        candidate.outcome === "handoff_requested")
+        candidate.outcome === "handoff_requested" &&
+        candidate.ticketStatus !== "partial" &&
+        candidate.issueUpdate !== "failed")
         .map((candidate) => ({
         runId: candidate.runId,
         createdAt: eventTime(candidate, "run.created"),
@@ -30,7 +38,7 @@ export function completionMarkOf(run, candidates) {
         (first.runId < second.runId ? -1 : 1))[0];
     return later === undefined
         ? { text: "Needs attention", laterRunId: null }
-        : { text: "Done in a later run", laterRunId: later.runId };
+        : { text: "Ticket completed by later run", laterRunId: later.runId };
 }
 export function activeRun(state) {
     return !terminalStates.includes(state);
@@ -39,10 +47,17 @@ export function recentRun(latestAt, now) {
     const age = Date.parse(now) - Date.parse(latestAt ?? "");
     return age >= 0 && age <= weekMilliseconds;
 }
-function stepNames(workflowId) {
+export function stagesFor(metadata, workflowId) {
+    return metadata !== undefined && Object.hasOwn(metadata, workflowId)
+        ? metadata[workflowId]
+        : undefined;
+}
+function stepNames(workflowId, stages) {
+    if (workflowId !== "develop-issue" && stages !== undefined)
+        return [...stages.map((stage) => stage.label), "Other"];
     return workflowId === "develop-issue"
         ? issueSteps.map((step) => step.name)
-        : ["Claude turn", "Your review"];
+        : ["Agent turn", "Your review"];
 }
 function operationOf(event) {
     const payload = record(record(event)?.["payload"]);
@@ -61,7 +76,7 @@ function stepName(event, workflowId) {
     if (type !== "effect.requested")
         return undefined;
     if (workflowId !== "develop-issue")
-        return "Claude turn";
+        return "Agent turn";
     return issueSteps.find((step) => step.operation === operationOf(event)[4])
         ?.name;
 }
@@ -72,10 +87,24 @@ function startedAt(event) {
 function chronological(events) {
     return events.toSorted((first, second) => Date.parse(startedAt(first) ?? "") - Date.parse(startedAt(second) ?? ""));
 }
-export function currentStepOf(events, workflowId) {
+function declaredStep(events, stages) {
+    const event = events
+        .filter((item) => ["effect.requested", "gate.opened"].includes(String(record(item)?.["type"])))
+        .toSorted((first, second) => Number(record(second)?.["sequence"]) -
+        Number(record(first)?.["sequence"]))[0];
+    const payload = record(record(event)?.["payload"]);
+    const selector = record(event)?.["type"] === "effect.requested" ? "operations" : "gateKinds";
+    const value = selector === "operations" ? operationOf(event)[4] : payload?.["gateKind"];
+    const stage = stages.find((item) => item[selector]?.some((name) => name === value));
+    return { name: stage?.label ?? "Other", startedAt: startedAt(event) };
+}
+export function currentStepOf(events, workflow) {
+    const { workflowId, stages } = workflow;
+    if (workflowId !== "develop-issue" && stages !== undefined)
+        return declaredStep(events, stages);
     const event = chronological(events).findLast((item) => stepName(item, workflowId) !== undefined);
     return {
-        name: stepName(event, workflowId) ?? stepNames(workflowId)[0] ?? "Claude turn",
+        name: stepName(event, workflowId) ?? stepNames(workflowId)[0] ?? "Agent turn",
         startedAt: startedAt(event),
     };
 }
@@ -99,8 +128,12 @@ function cardOf(run, runs) {
     return {
         runId: run.runId,
         title: run.title,
+        ...linksOf(run),
         completionMark: completionMarkOf(run, runs),
+        pullRequestObservation: null,
         claudeCostUsd: run.claudeCostUsd,
+        estimatedCostUsd: run.estimatedCostUsd,
+        usage: run.usage,
         currentStep: activeRun(run.state) ? run.currentStep : null,
         endedAt: activeRun(run.state) ? null : run.latestAt,
         decisionWaiting: run.decisions.length > 0,
@@ -144,7 +177,11 @@ export function boardsOf(inputs, runs) {
             : inputs.summaries
                 .filter((value) => record(value)?.["workflowId"] === workflowId)
                 .map(summaryOf);
-        const columns = [...stepNames(workflowId), "Done", "Stopped"].map((name) => {
+        const columns = [
+            ...stepNames(workflowId, stagesFor(inputs.workflowStages, workflowId)),
+            "Done",
+            "Stopped",
+        ].map((name) => {
             const cards = own
                 .filter((run) => columnOf(run, inputs.updatedAt) === name)
                 .map((run) => cardOf(run, inputs.completionCandidates ?? runs));

package/dist/src/cli/watch-card-client.d.ts

@@ -0,0 +1 @@
+export declare const watchCardClient = "\nasync function submitCard(workflowId) {\n  const draft = state.cards[workflowId];\n  if (!draft || draft.pending || draft.admitted) return;\n  state.cards[workflowId] = { ...draft, pending: true, message: \"\" };\n  draw();\n  let result;\n  try {\n    const response = await fetch(\"actions/run\", {\n      method: \"POST\",\n      headers: { \"content-type\": \"application/json\", \"x-cloving-token\": actionToken },\n      body: JSON.stringify({ workflowId, fields: draft.fields, commandId: draft.commandId }),\n    });\n    result = response.ok ? cardReply(await response.json()) : { admitted: false, message: \"request-refused: Refresh the page and check the input (16 KiB maximum).\" };\n  } catch {\n    result = cardReply({ kind: \"error\", error: { code: \"outcome-unknown\" } });\n  }\n  if (state.cards[workflowId]?.commandId !== draft.commandId) return;\n  state.cards[workflowId] = { ...draft, ...result, pending: false };\n  draw();\n}\n\nfunction cardControls(model, workflowId) {\n  if (actionToken === null || workflowId === null) return undefined;\n  const form = model?.cardForms?.find((item) => item.workflowId === workflowId);\n  if (form === undefined) return undefined;\n  const draft = state.cards[workflowId] ?? null;\n  return { draft, onOpen() {\n    state.cards[workflowId] = { commandId: crypto.randomUUID(), fields: {}, pending: false, admitted: false, message: \"\" };\n    draw();\n    document.querySelector(\".add-card-form input, .add-card-form textarea, .add-card-form button\")?.focus();\n  }, onCancel() {\n    delete state.cards[workflowId];\n    draw();\n    document.querySelector(\".add-card\")?.focus();\n  },\n  onChange(name, value) {\n    const fields = { ...state.cards[workflowId].fields, [name]: value };\n    if (form.fields.find((field) => field.name === name)?.optional && !value.trim())\n      delete fields[name];\n    state.cards[workflowId] = { ...state.cards[workflowId], fields };\n  }, onSubmit() { submitCard(workflowId); } };\n}\n";

package/dist/src/cli/watch-card-client.js

@@ -0,0 +1,44 @@
+export const watchCardClient = `
+async function submitCard(workflowId) {
+  const draft = state.cards[workflowId];
+  if (!draft || draft.pending || draft.admitted) return;
+  state.cards[workflowId] = { ...draft, pending: true, message: "" };
+  draw();
+  let result;
+  try {
+    const response = await fetch("actions/run", {
+      method: "POST",
+      headers: { "content-type": "application/json", "x-cloving-token": actionToken },
+      body: JSON.stringify({ workflowId, fields: draft.fields, commandId: draft.commandId }),
+    });
+    result = response.ok ? cardReply(await response.json()) : { admitted: false, message: "request-refused: Refresh the page and check the input (16 KiB maximum)." };
+  } catch {
+    result = cardReply({ kind: "error", error: { code: "outcome-unknown" } });
+  }
+  if (state.cards[workflowId]?.commandId !== draft.commandId) return;
+  state.cards[workflowId] = { ...draft, ...result, pending: false };
+  draw();
+}
+
+function cardControls(model, workflowId) {
+  if (actionToken === null || workflowId === null) return undefined;
+  const form = model?.cardForms?.find((item) => item.workflowId === workflowId);
+  if (form === undefined) return undefined;
+  const draft = state.cards[workflowId] ?? null;
+  return { draft, onOpen() {
+    state.cards[workflowId] = { commandId: crypto.randomUUID(), fields: {}, pending: false, admitted: false, message: "" };
+    draw();
+    document.querySelector(".add-card-form input, .add-card-form textarea, .add-card-form button")?.focus();
+  }, onCancel() {
+    delete state.cards[workflowId];
+    draw();
+    document.querySelector(".add-card")?.focus();
+  },
+  onChange(name, value) {
+    const fields = { ...state.cards[workflowId].fields, [name]: value };
+    if (form.fields.find((field) => field.name === name)?.optional && !value.trim())
+      delete fields[name];
+    state.cards[workflowId] = { ...state.cards[workflowId], fields };
+  }, onSubmit() { submitCard(workflowId); } };
+}
+`;

package/dist/src/cli/watch-card-forms.d.ts

@@ -0,0 +1,2 @@
+import { type CardForm } from "./watch-run-input.ts";
+export declare function watchCardForms(directory: string): Promise<readonly CardForm[]>;