cloving 1.0.1 → 1.2.0

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

@@ -0,0 +1,33 @@
+import { readdir, readFile } from "node:fs/promises";
+import { join } from "node:path";
+import { isWorkflowDeclaration } from "../workflow-declaration.js";
+import { builtinCardForms } from "./watch-run-input.js";
+export async function watchCardForms(directory) {
+    const forms = [...builtinCardForms()];
+    const files = await readdir(directory).catch(() => []);
+    for (const file of files
+        .filter((name) => name.endsWith(".declaration.json"))
+        .sort()) {
+        const value = await readFile(join(directory, file), "utf8")
+            .then((text) => JSON.parse(text))
+            .catch(() => null);
+        if (!isWorkflowDeclaration(value))
+            continue;
+        const entries = Object.entries(value.input.fields);
+        if (!entries.every(([, rule]) => rule === "string" || rule.type === "string"))
+            continue;
+        if (forms.some((form) => form.workflowId === value.workflowId))
+            continue;
+        forms.push({
+            workflowId: value.workflowId,
+            source: "input",
+            fields: entries.map(([name, rule]) => ({
+                name,
+                label: name,
+                multiline: false,
+                optional: rule !== "string" && rule.optional === true,
+            })),
+        });
+    }
+    return forms;
+}

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

@@ -0,0 +1,5 @@
+import type { Reply } from "../protocol.ts";
+export declare function cardReply(reply: Reply): {
+    readonly admitted: boolean;
+    readonly message: string;
+};

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

@@ -0,0 +1,34 @@
+export function cardReply(reply) {
+    if (reply.kind === "result")
+        return {
+            admitted: true,
+            message: `Run ${String(reply.result["runId"])} is admitted`,
+        };
+    const explanations = {
+        "workflow-active": "Add the label cloving: ready to the issue to put it in the queue.",
+        "unknown-workflow": "This workflow is no longer registered. Refresh the page.",
+        "workflow-unavailable": "A required workflow capability is unavailable.",
+        "invalid-submission": "Check the workflow fields.",
+        "input-too-large": "Shorten the input and try again.",
+        "invalid-request": "The service could not read this run request.",
+        "conflicting-command": "This form was already sent with different fields. Open a new form.",
+        "service-unavailable": "Start the Cloving service and retry this form.",
+        "authority-unavailable": "The service authority is unavailable. Retry this form later.",
+        "permission-denied": "The service refused access to this account.",
+        "outcome-unknown": "The reply was lost. Retry this form with the same command ID.",
+        "resolver-timeout": "The input resolver timed out. Retry this form.",
+        "resolver-failure": "The input resolver failed. Check the service before retrying.",
+        "invalid-ticket-id": "Enter a valid issue number or ticket ID.",
+        "ticket-source-not-configured": "Configure the daemon ticket command first.",
+        "ticket-not-available": "The ticket could not be read.",
+        "next-source-not-configured": "Configure the daemon next-ticket command first.",
+        "next-ticket-not-available": "The next ticket could not be read.",
+        "no-ready-ticket": "There is no ready ticket in the queue.",
+        "unsupported-prompt": "This workflow requires declared input fields.",
+    };
+    const { code } = reply.error;
+    return {
+        admitted: false,
+        message: `${code}: ${explanations[code] ?? "The service refused this run."}`,
+    };
+}

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

@@ -0,0 +1,40 @@
+import { type Shown } from "./watch-element.ts";
+import type { CardField, CardForm } from "./watch-run-input.ts";
+export interface CardDraft {
+    readonly commandId: string;
+    readonly fields: Readonly<Record<string, string>>;
+    readonly pending: boolean;
+    readonly admitted: boolean;
+    readonly message: string;
+}
+export interface CardControls {
+    readonly draft: CardDraft | null;
+    readonly onOpen: () => void;
+    readonly onCancel: () => void;
+    readonly onChange: (name: string, value: string) => void;
+    readonly onSubmit: () => void;
+}
+export interface CardKeyEvent {
+    readonly key: string;
+    readonly defaultPrevented?: boolean;
+    readonly isComposing?: boolean;
+    readonly repeat?: boolean;
+    readonly ctrlKey?: boolean;
+    readonly metaKey?: boolean;
+    readonly target?: {
+        readonly localName?: string;
+    };
+    readonly currentTarget: object;
+    readonly preventDefault: () => void;
+}
+export declare function cardSubmitKey(event: CardKeyEvent): boolean;
+export declare function cardKey(event: CardKeyEvent, controls: CardControls): void;
+export declare function CardInput(props: {
+    readonly field: CardField;
+    readonly controls: CardControls;
+    readonly draft: CardDraft;
+}): Shown;
+export declare function AddCard(props: {
+    readonly form: CardForm | undefined;
+    readonly controls: CardControls | undefined;
+}): Shown;

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

@@ -0,0 +1,86 @@
+import { component, element } from "./watch-element.js";
+export function cardSubmitKey(event) {
+    const name = event.target?.localName;
+    return (name === "input" ||
+        (name === "textarea" && Boolean(event.ctrlKey || event.metaKey)));
+}
+export function cardKey(event, controls) {
+    if (event.defaultPrevented || event.isComposing || event.repeat)
+        return;
+    if (event.key === "Escape") {
+        event.preventDefault();
+        controls.onCancel();
+        return;
+    }
+    if (event.key !== "Enter")
+        return;
+    if (!cardSubmitKey(event))
+        return;
+    event.preventDefault();
+    const prototype = Reflect.getPrototypeOf(event.currentTarget);
+    if (prototype === null)
+        return;
+    const requestSubmit = Reflect.get(prototype, "requestSubmit");
+    if (typeof requestSubmit === "function")
+        Reflect.apply(requestSubmit, event.currentTarget, []);
+}
+export function CardInput(props) {
+    const { field, controls, draft } = props;
+    return element("label", {
+        children: [
+            field.label,
+            element(field.multiline ? "textarea" : "input", {
+                name: field.name,
+                type: field.multiline ? undefined : "text",
+                rows: field.multiline ? 5 : undefined,
+                value: draft.fields[field.name] ?? "",
+                required: !field.optional,
+                disabled: draft.pending || draft.admitted,
+                onInput: (event) => {
+                    controls.onChange(field.name, event.currentTarget.value);
+                },
+            }),
+        ],
+    });
+}
+export function AddCard(props) {
+    const { form, controls } = props;
+    if (form === undefined || controls === undefined)
+        return null;
+    const { draft } = controls;
+    if (draft === null)
+        return element("button", {
+            class: "add-card",
+            type: "button",
+            onClick: controls.onOpen,
+            children: "+ Add a card",
+        });
+    return element("form", {
+        class: "add-card-form",
+        onKeyDown: (event) => {
+            cardKey(event, controls);
+        },
+        onSubmit: (event) => {
+            event.preventDefault();
+            controls.onSubmit();
+        },
+        children: [
+            form.fields.map((field) => component(CardInput, { key: field.name, field, controls, draft })),
+            element("button", {
+                type: "submit",
+                disabled: draft.pending || draft.admitted,
+                children: draft.pending ? "Adding…" : "Add card",
+            }),
+            element("button", {
+                type: "button",
+                onClick: controls.onCancel,
+                children: "Cancel",
+            }),
+            element("p", {
+                role: "status",
+                "aria-live": "polite",
+                children: draft.message,
+            }),
+        ],
+    });
+}

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

@@ -0,0 +1 @@
+export declare const watchClient = "\nconst state = { model: null, receivedAt: 0, stale: false, copied: \"\", label: \"\", run: \"\", loading: false, again: false, columns: {}, cards: {}, start: null, hovered: null, focused: null };\nfunction readPreference(key) {\n  try { return JSON.parse(localStorage.getItem(key)); }\n  catch { return null; }\n}\nfunction readColumnChoices(key) {\n  const value = readPreference(key);\n  if (typeof value !== \"object\" || value === null || Array.isArray(value)) return null;\n  return Object.fromEntries(Object.entries(value).filter(([, choice]) => typeof choice === \"boolean\"));\n}\nfunction savePreference(key, value) {\n  try { localStorage.setItem(key, JSON.stringify(value)); }\n  catch {}\n}\nfunction startControls() {\n  if (state.start === null) state.start = readPreference(\"cloving.watch.start\") === true;\n  return { shown: state.start, onToggle() {\n    state.start = !state.start;\n    savePreference(\"cloving.watch.start\", state.start);\n    draw();\n  } };\n}\nfunction columnControls(model, selected) {\n  const workflowId = model === null ? null : boardWorkflow(model, watchLocation(selected).workflowId);\n  if (workflowId === null) return undefined;\n  const key = \"cloving.watch.columns:\" + workflowId;\n  if (!Object.hasOwn(state.columns, workflowId))\n    state.columns = { ...state.columns, [workflowId]: readColumnChoices(key) };\n  const choices = state.columns[workflowId];\n  return { choices, onHover(name) { state.hovered = name; }, onFocus(name) { state.focused = name; }, onToggle(name) {\n    const changed = { ...choices, [name]: !columnCollapsed(choices, name) };\n    state.columns = { ...state.columns, [workflowId]: changed };\n    savePreference(key, changed);\n    draw();\n  } };\n}\nfunction moved(next, followed) {\n  const arrived = next === \"waiting_gate\" && next !== state.run;\n  state.run = next;\n  if (arrived) scrollTo(0, 0);\n  else if (followed && next === \"running\") scrollTo(0, document.body.scrollHeight);\n}\nfunction copy(command) {\n  const shown = (label) => {\n    state.copied = command;\n    state.label = label;\n    draw();\n  };\n  navigator.clipboard.writeText(command).then(\n    () => { shown(\"Copied\"); },\n    () => { shown(\"Copy failed\"); },\n  );\n}\nfunction draw() {\n  const { model, stale } = state;\n  const selected = location.hash.slice(1);\n  const followed = innerHeight + scrollY >= document.body.scrollHeight - 80;\n  const copying = { command: state.copied, label: state.label, onCopy: copy };\n  const now = new Date().toISOString();\n  const observationNow = model === null ? now : new Date(Date.parse(model.updatedAt) + performance.now() - state.receivedAt).toISOString();\n  const columns = columnControls(model, selected);\n  const start = model === null ? undefined : startControls();\n  const cards = cardControls(model, model === null ? null : boardWorkflow(model, watchLocation(selected).workflowId));\n  const page = component(Page, { model, selected, now, observationNow, stale, copying, columns, start, cards });\n  render(page, document.getElementById(\"app\"));\n  if (model === null) return;\n  document.title = watchTitle(model, selected);\n  const { runId } = watchLocation(selected);\n  moved(model.runs.find((run) => run.runId === runId)?.state ?? \"\", followed);\n}\nasync function withSelectedRun(model) {\n  const { runId } = watchLocation(location.hash);\n  if (runId === null || model.runs.some((run) => run.runId === runId)) return model;\n  const detail = await fetch(\"data.json?runId=\" + encodeURIComponent(runId), { cache: \"no-store\" });\n  if (detail.status === 404) return model;\n  if (!detail.ok) throw new Error(\"watch-run-not-available\");\n  const { run } = await detail.json();\n  if (run?.runId !== runId) throw new Error(\"watch-run-mismatch\");\n  return { ...model, runs: [...model.runs, run] };\n}\nasync function load() {\n  state.again = state.loading;\n  if (state.loading) return;\n  state.loading = true;\n  try {\n    const reply = await fetch(\"data.json\", { cache: \"no-store\" });\n    if (!reply.ok) throw new Error(\"watch-not-available\");\n    const model = await reply.json();\n    const receivedAt = performance.now();\n    state.model = await withSelectedRun(model);\n    state.receivedAt = receivedAt;\n    state.stale = false;\n  } catch {\n    state.stale = true;\n  }\n  state.loading = false;\n  draw();\n  if (state.again) load();\n}\nfunction listen() {\n  const source = new EventSource(\"events\");\n  source.onmessage = () => { load(); };\n  source.onerror = () => { state.stale = true; draw(); };\n}\naddEventListener(\"keydown\", (event) => {\n  if (event.key !== String.fromCharCode(92) || event.defaultPrevented || event.repeat || event.isComposing) return;\n  if (event.ctrlKey || event.altKey || event.metaKey || event.shiftKey) return;\n  if (event.target?.closest?.(\"input, textarea, select, [contenteditable]\")) return;\n  const target = state.hovered ?? state.focused;\n  if (target === null || watchLocation(location.hash).runId !== null) return;\n  const controls = columnControls(state.model, location.hash);\n  if (controls === undefined) return;\n  event.preventDefault();\n  controls.onToggle(target);\n});\naddEventListener(\"hashchange\", () => { state.run = \"\"; state.hovered = null; state.focused = null; draw(); load(); });\ndraw();\nlisten();\nsetInterval(draw, 1000);\nsetInterval(load, 15000);\n";

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

@@ -0,0 +1,122 @@
+export const watchClient = `
+const state = { model: null, receivedAt: 0, stale: false, copied: "", label: "", run: "", loading: false, again: false, columns: {}, cards: {}, start: null, hovered: null, focused: null };
+function readPreference(key) {
+  try { return JSON.parse(localStorage.getItem(key)); }
+  catch { return null; }
+}
+function readColumnChoices(key) {
+  const value = readPreference(key);
+  if (typeof value !== "object" || value === null || Array.isArray(value)) return null;
+  return Object.fromEntries(Object.entries(value).filter(([, choice]) => typeof choice === "boolean"));
+}
+function savePreference(key, value) {
+  try { localStorage.setItem(key, JSON.stringify(value)); }
+  catch {}
+}
+function startControls() {
+  if (state.start === null) state.start = readPreference("cloving.watch.start") === true;
+  return { shown: state.start, onToggle() {
+    state.start = !state.start;
+    savePreference("cloving.watch.start", state.start);
+    draw();
+  } };
+}
+function columnControls(model, selected) {
+  const workflowId = model === null ? null : boardWorkflow(model, watchLocation(selected).workflowId);
+  if (workflowId === null) return undefined;
+  const key = "cloving.watch.columns:" + workflowId;
+  if (!Object.hasOwn(state.columns, workflowId))
+    state.columns = { ...state.columns, [workflowId]: readColumnChoices(key) };
+  const choices = state.columns[workflowId];
+  return { choices, onHover(name) { state.hovered = name; }, onFocus(name) { state.focused = name; }, onToggle(name) {
+    const changed = { ...choices, [name]: !columnCollapsed(choices, name) };
+    state.columns = { ...state.columns, [workflowId]: changed };
+    savePreference(key, changed);
+    draw();
+  } };
+}
+function moved(next, followed) {
+  const arrived = next === "waiting_gate" && next !== state.run;
+  state.run = next;
+  if (arrived) scrollTo(0, 0);
+  else if (followed && next === "running") scrollTo(0, document.body.scrollHeight);
+}
+function copy(command) {
+  const shown = (label) => {
+    state.copied = command;
+    state.label = label;
+    draw();
+  };
+  navigator.clipboard.writeText(command).then(
+    () => { shown("Copied"); },
+    () => { shown("Copy failed"); },
+  );
+}
+function draw() {
+  const { model, stale } = state;
+  const selected = location.hash.slice(1);
+  const followed = innerHeight + scrollY >= document.body.scrollHeight - 80;
+  const copying = { command: state.copied, label: state.label, onCopy: copy };
+  const now = new Date().toISOString();
+  const observationNow = model === null ? now : new Date(Date.parse(model.updatedAt) + performance.now() - state.receivedAt).toISOString();
+  const columns = columnControls(model, selected);
+  const start = model === null ? undefined : startControls();
+  const cards = cardControls(model, model === null ? null : boardWorkflow(model, watchLocation(selected).workflowId));
+  const page = component(Page, { model, selected, now, observationNow, stale, copying, columns, start, cards });
+  render(page, document.getElementById("app"));
+  if (model === null) return;
+  document.title = watchTitle(model, selected);
+  const { runId } = watchLocation(selected);
+  moved(model.runs.find((run) => run.runId === runId)?.state ?? "", followed);
+}
+async function withSelectedRun(model) {
+  const { runId } = watchLocation(location.hash);
+  if (runId === null || model.runs.some((run) => run.runId === runId)) return model;
+  const detail = await fetch("data.json?runId=" + encodeURIComponent(runId), { cache: "no-store" });
+  if (detail.status === 404) return model;
+  if (!detail.ok) throw new Error("watch-run-not-available");
+  const { run } = await detail.json();
+  if (run?.runId !== runId) throw new Error("watch-run-mismatch");
+  return { ...model, runs: [...model.runs, run] };
+}
+async function load() {
+  state.again = state.loading;
+  if (state.loading) return;
+  state.loading = true;
+  try {
+    const reply = await fetch("data.json", { cache: "no-store" });
+    if (!reply.ok) throw new Error("watch-not-available");
+    const model = await reply.json();
+    const receivedAt = performance.now();
+    state.model = await withSelectedRun(model);
+    state.receivedAt = receivedAt;
+    state.stale = false;
+  } catch {
+    state.stale = true;
+  }
+  state.loading = false;
+  draw();
+  if (state.again) load();
+}
+function listen() {
+  const source = new EventSource("events");
+  source.onmessage = () => { load(); };
+  source.onerror = () => { state.stale = true; draw(); };
+}
+addEventListener("keydown", (event) => {
+  if (event.key !== String.fromCharCode(92) || event.defaultPrevented || event.repeat || event.isComposing) return;
+  if (event.ctrlKey || event.altKey || event.metaKey || event.shiftKey) return;
+  if (event.target?.closest?.("input, textarea, select, [contenteditable]")) return;
+  const target = state.hovered ?? state.focused;
+  if (target === null || watchLocation(location.hash).runId !== null) return;
+  const controls = columnControls(state.model, location.hash);
+  if (controls === undefined) return;
+  event.preventDefault();
+  controls.onToggle(target);
+});
+addEventListener("hashchange", () => { state.run = ""; state.hovered = null; state.focused = null; draw(); load(); });
+draw();
+listen();
+setInterval(draw, 1000);
+setInterval(load, 15000);
+`;

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

@@ -1,4 +1,10 @@
+import type { WorkflowStages } from "../workflow-declaration.ts";
+import { type WorkflowRefusal } from "../workflow-refusals.ts";
 import type { WatchDecision, WatchItem, WatchModel, WatchTurn } from "./watch-render.ts";
+import { type GithubRecords } from "./watch-pull-request.ts";
+export type { GithubRecords } from "./watch-pull-request.ts";
+import { type PrRepository } from "./watch-pr-identity.ts";
+type Fields = Readonly<Record<string, unknown>>;
 export declare function activityOf(line: string): WatchItem[];
 export interface TurnRecords {
     readonly key: string;
@@ -10,7 +16,11 @@ export interface TurnRecords {
 export declare function turnOf(records: TurnRecords): WatchTurn;
 export declare function decisionCommands(decision: unknown, client: string): WatchDecision;
 export interface WatchInputs {
+    readonly queue?: Fields;
+    readonly repository?: PrRepository | null;
     readonly workflows: readonly string[];
+    readonly workflowRefusals?: readonly WorkflowRefusal[];
+    readonly workflowStages?: WorkflowStages;
     readonly summaries?: readonly unknown[];
     readonly home: string;
     readonly client: string;
@@ -22,8 +32,4 @@ export interface WatchInputs {
     readonly turns: readonly WatchTurn[];
     readonly githubRecords: readonly GithubRecords[];
 }
-export interface GithubRecords {
-    readonly started: unknown;
-    readonly result: unknown;
-}
 export declare function watchModel(inputs: WatchInputs): WatchModel;

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

@@ -1,5 +1,14 @@
-import { boardsOf, currentStepOf, roundOf, startWorkflowOf, } from "./watch-board.js";
+import { operationalDecision } from "../decision-visibility.js";
+import { workflowRefusals, } from "../workflow-refusals.js";
+import { isTicketStatus } from "../ticket-status.js";
+import { isPromotionId } from "../workflow-contracts.js";
+import { priceFields, statusTurns } from "./watch-usage.js";
+import { priceOf, usageOf } from "../worker-usage.js";
+import { priceText } from "./usage-render.js";
+import { boardsOf, currentStepOf, roundOf, stagesFor, startWorkflowOf, } from "./watch-board.js";
 import { decisionOf, phasesOf } from "./watch-phases.js";
+import { pullOf } from "./watch-pull-request.js";
+import { establishedIssue } from "./watch-pr-identity.js";
 import { displayRun } from "./watch-paths.js";
 const textLimit = 600;
 const activityLimit = 400;
@@ -59,7 +68,7 @@ function failed(part) {
     return [{ kind: "error", text: shown }];
 }
 function ended(line) {
-    const cost = count(line["total_cost_usd"]);
+    const cost = priceOf(line["total_cost_usd"]);
     return [
         {
             kind: "result",
@@ -79,13 +88,6 @@ export function activityOf(line) {
         return parts(value).flatMap(failed);
     return value["type"] === "result" ? ended(value) : [];
 }
-function costOf(lines) {
-    const costs = lines
-        .map((line) => record(parsed(line)))
-        .filter((value) => value["type"] === "result")
-        .map((value) => count(value["total_cost_usd"]));
-    return costs.at(-1) ?? null;
-}
 function concise(items) {
     return items.map((item, index) => {
         const before = items[index - 1];
@@ -103,8 +105,9 @@ function shortened(run) {
         turns: run.turns.map((turn) => ({
             ...turn,
             activity: concise(turn.activity.map((item) => {
-                const cost = item.costUsd;
-                const spent = cost === undefined ? "" : ` (cost ${cost.toFixed(2)} USD)`;
+                const spent = item.kind === "result"
+                    ? ` (cost ${priceText(item.costUsd, turn.estimatedCostUsd)})`
+                    : "";
                 return { kind: item.kind, text: `${cut(item.text)}${spent}` };
             })).slice(-activityLimit),
         })),
@@ -118,14 +121,26 @@ export function turnOf(records) {
     const report = record(parsed(text(result["result"])));
     return {
         key: records.key,
+        operationId: text(started["operationId"]),
+        usage: usageOf(report["usage"]),
         runId: text(operation[2]),
         target: text(started["target"]),
         branch: text(started["branch"]),
         worktree: text(started["worktree"]),
         startedAt: text(started["startedAt"]),
         outcome: records.result === null ? "in work" : outcome,
-        costUsd: costOf(records.lines),
-        activity: records.lines.flatMap(activityOf).slice(-activityLimit - 1),
+        costUsd: priceOf(report["costUsd"]),
+        estimatedCostUsd: priceOf(report["estimatedCostUsd"]),
+        activity: records.lines
+            .flatMap(activityOf)
+            .map((item) => item.kind === "result"
+            ? {
+                kind: item.kind,
+                text: item.text,
+                ...priceFields(report["costUsd"]),
+            }
+            : item)
+            .slice(-activityLimit - 1),
         endedAt: stamp(result["endedAt"]),
         activeAt: records.activeAt ?? null,
         commits: texts(report["commits"]),
@@ -146,54 +161,6 @@ export function decisionCommands(decision, client) {
         deny: `${client} deny ${decisionId} --text "<feedback>" ${binding}`,
     };
 }
-function githubOf(records) {
-    const started = record(records.started);
-    const operation = list(parsed(text(started["operationId"])));
-    const result = record(records.result);
-    const completed = result["outcome"] === "completed";
-    return {
-        runId: text(operation[2]),
-        round: Number(operation[1]),
-        method: text(started["method"]),
-        report: completed ? record(parsed(text(result["result"]))) : {},
-    };
-}
-function pullRequestOf(results) {
-    const opened = results
-        .filter((item) => item.method === "open-pr")
-        .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"]) };
-}
-function reviewsOf(results) {
-    return results
-        .filter((item) => item.method === "wait-review")
-        .flatMap(({ round, report }) => {
-        const score = count(report["score"]);
-        if (score === null)
-            return [];
-        return [{ round, commit: text(report["commit"]), score }];
-    });
-}
-function mergeCommitOf(results) {
-    const merged = results
-        .filter((item) => item.method === "merge")
-        .map((item) => stamp(item.report["merged"]));
-    return merged.find((commit) => commit !== null) ?? null;
-}
-function pullOf(inputs, runId) {
-    const results = inputs.githubRecords
-        .map(githubOf)
-        .filter((item) => item.runId === runId)
-        .toSorted((first, second) => first.round - second.round);
-    return {
-        pullRequest: pullRequestOf(results),
-        reviews: reviewsOf(results),
-        mergeCommit: mergeCommitOf(results),
-    };
-}
 function feedbackOf(value) {
     const fields = record(value);
     return {
@@ -209,21 +176,43 @@ function eventOf(value) {
         type: text(fields["type"]),
     };
 }
+function outcomeOf(value) {
+    const fields = record(value);
+    const { promotionId, ticketStatus, issueUpdate } = fields;
+    return {
+        outcome: stamp(fields["kind"]),
+        ...(isPromotionId(promotionId) ? { promotionId } : {}),
+        ...(isTicketStatus(ticketStatus) ? { ticketStatus } : {}),
+        ...(issueUpdate === "failed" ? { issueUpdate } : {}),
+    };
+}
 function runOf(inputs, value) {
     const status = record(record(value)["status"]);
     const runId = text(status["runId"]);
     const workflowId = text(status["workflowId"]);
     const budget = record(status["budget"]);
     const ticketId = text(status["ticketId"]);
+    const issue = workflowId === "develop-issue"
+        ? establishedIssue(inputs.repository ?? null, status["issueIdentity"])
+        : null;
     return {
         runId,
         workflowId,
+        parentRunId: stamp(status["parentRunId"]),
+        chainId: stamp(status["chainId"]) ?? runId,
+        childRunIds: texts(status["childRunIds"]),
         ticketId: ticketId === "" ? null : ticketId,
+        ...(issue === null ? {} : { issueIdentity: issue }),
         title: stamp(status["title"]),
-        outcome: stamp(record(status["outcome"])["kind"]),
+        ...outcomeOf(status["outcome"]),
         latestAt: stamp(status["latestAt"]),
-        claudeCostUsd: count(status["claudeCostUsd"]) ?? 0,
-        currentStep: currentStepOf(list(record(value)["events"]), workflowId),
+        claudeCostUsd: priceOf(status["claudeCostUsd"]),
+        estimatedCostUsd: priceOf(status["estimatedCostUsd"]),
+        usage: usageOf(status["usage"]),
+        currentStep: currentStepOf(list(record(value)["events"]), {
+            workflowId,
+            stages: stagesFor(inputs.workflowStages, workflowId),
+        }),
         round: roundOf(list(record(value)["events"])),
         state: text(status["state"]),
         code: text(record(status["reason"])["code"]),
@@ -232,13 +221,16 @@ function runOf(inputs, value) {
         limit: count(budget["limit"]),
         decisions: inputs.decisions
             .filter((decision) => record(decision)["runId"] === runId)
-            .map((decision) => decisionCommands(decision, inputs.client)),
+            .map((decision) => decisionCommands(operationalDecision(record(decision), workflowId), inputs.client)),
         events: list(record(value)["events"]).map(eventOf),
-        turns: inputs.turns.filter((turn) => turn.runId === runId),
+        turns: statusTurns(inputs.turns, status),
         phases: phasesOf(list(record(value)["events"]), workflowId),
         decision: decisionOf(list(record(value)["events"])),
         feedback: list(status["feedback"]).map(feedbackOf),
-        ...pullOf(inputs, runId),
+        ...pullOf({
+            records: inputs.githubRecords,
+            repository: workflowId === "develop-issue" ? (inputs.repository ?? null) : null,
+        }, runId),
     };
 }
 function began(run) {
@@ -253,6 +245,8 @@ export function watchModel(inputs) {
     const workflows = boardsOf({ ...inputs, completionCandidates: candidates }, runs);
     return {
         workflows,
+        ...(inputs.queue === undefined ? {} : { queue: inputs.queue }),
+        workflowRefusals: workflowRefusals(inputs.workflowRefusals),
         startWorkflowId: startWorkflowOf(workflows),
         updatedAt: inputs.updatedAt,
         service: inputs.service,

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

@@ -1 +1 @@
-export declare function pageDocument(): string;
+export declare function pageDocument(actionToken?: string | null): string;