cloving 1.2.0 → 1.3.0

package/dist/src/review-subject.js

@@ -0,0 +1,91 @@
+import { record } from "./protocol.js";
+export function reviewSubjectText(subject) {
+    if (record(subject) === undefined)
+        throw new Error("invalid-review-subject");
+    if ("draft" in subject)
+        return draftReviewText(subject);
+    if (!commitId(subject.commit) ||
+        typeof subject.target !== "string" ||
+        subject.target.trim() === "")
+        throw new Error("invalid-review-subject");
+    const identity = [
+        "cloving-review-subject",
+        1,
+        "commit",
+        subject.target,
+        subject.commit,
+    ];
+    if (subject.number !== undefined)
+        identity.push(subject.number);
+    return JSON.stringify(identity);
+}
+function draftReviewText(subject) {
+    if (typeof subject.draft !== "string" ||
+        subject.draft.trim() === "" ||
+        (subject.commit !== undefined && !commitId(subject.commit)))
+        throw new Error("invalid-review-subject");
+    return JSON.stringify([
+        "cloving-review-subject",
+        1,
+        "draft",
+        subject.commit ?? null,
+        subject.draft,
+    ]);
+}
+export function commitId(value) {
+    return (typeof value === "string" && /^(?:[0-9a-f]{40}|[0-9a-f]{64})$/.test(value));
+}
+export function reviewReport(text) {
+    const trimmed = text.trimEnd();
+    const start = trimmed.lastIndexOf("\n") + 1;
+    const line = trimmed.slice(start);
+    const verdict = line.slice("Review verdict: ".length);
+    if (!line.startsWith("Review verdict: ") ||
+        (verdict !== "accept" && verdict !== "change"))
+        return { reviewVerdict: null, feedback: text };
+    return {
+        reviewVerdict: verdict,
+        feedback: trimmed.slice(0, start).trimEnd(),
+    };
+}
+export function reviewReportStream(limit) {
+    let text = "";
+    let trailing = "";
+    let prefix = "";
+    let length = 0;
+    let contentLength = 0;
+    let verdict = null;
+    const finish = () => {
+        if (contentLength > 0)
+            verdict =
+                contentLength > 24
+                    ? null
+                    : reviewReport(prefix.slice(0, contentLength)).reviewVerdict;
+        prefix = "";
+        length = 0;
+        contentLength = 0;
+    };
+    return {
+        write: (chunk) => {
+            const trimmed = chunk.trimEnd();
+            if (trimmed === "")
+                trailing = (trailing + chunk).slice(-limit);
+            if (trimmed !== "") {
+                text = (text + trailing + trimmed).slice(-limit);
+                trailing = chunk.slice(trimmed.length).slice(-limit);
+            }
+            for (const [index, part] of chunk.split("\n").entries()) {
+                if (index > 0)
+                    finish();
+                if (part.trimEnd() !== "")
+                    contentLength = Math.min(25, length + part.trimEnd().length);
+                prefix = (prefix + part).slice(0, 24);
+                length = Math.min(25, length + part.length);
+            }
+        },
+        result: () => {
+            finish();
+            return { reviewVerdict: verdict, feedback: reviewReport(text).feedback };
+        },
+    };
+}

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

@@ -0,0 +1,23 @@
+import type { RunWaitOutcome, RunWaitRequest } from "./step-bridge.ts";
+export interface RunWaitTarget {
+    readonly parentRunId: string | null;
+    readonly status: string;
+    readonly endedAt: number | null;
+    readonly outcome: RunWaitOutcome | null;
+}
+export type RunWaitResult = {
+    readonly kind: "waiting";
+    readonly deadline: number;
+} | {
+    readonly kind: "completed";
+    readonly outcome: RunWaitOutcome;
+} | {
+    readonly kind: "refused";
+    readonly reason: string;
+};
+export declare function runWaitResult(request: RunWaitRequest, context: {
+    readonly callerRunId: string;
+    readonly startedAt: number;
+    readonly now: number;
+    readonly target: RunWaitTarget | undefined;
+}): RunWaitResult;

package/dist/src/run-wait.js

@@ -0,0 +1,20 @@
+function validSeconds(seconds) {
+    return Number.isInteger(seconds) && seconds >= 1 && seconds <= 86400;
+}
+export function runWaitResult(request, context) {
+    const { target, callerRunId, startedAt, now } = context;
+    const seconds = request.maximumWaitSeconds;
+    if (!validSeconds(seconds) ||
+        target?.parentRunId !== callerRunId ||
+        request.runId === callerRunId)
+        return { kind: "refused", reason: "run-wait-refused" };
+    const deadline = startedAt + seconds * 1000;
+    if (["completed", "failed", "cancelled"].includes(target.status) &&
+        target.outcome !== null &&
+        target.endedAt !== null &&
+        target.endedAt <= deadline)
+        return { kind: "completed", outcome: target.outcome };
+    if (now >= deadline)
+        return { kind: "refused", reason: "run-wait-timeout" };
+    return { kind: "waiting", deadline };
+}

package/dist/src/service/active-tickets.d.ts

@@ -0,0 +1,4 @@
+import { type Fields } from "../protocol.ts";
+import type { ServiceContext } from "./replies.ts";
+export declare function activeWorkflow(context: ServiceContext, workflowId: string): Promise<Fields[]>;
+export declare function queueOverview(context: ServiceContext): Promise<Fields>;

package/dist/src/service/active-tickets.js

@@ -0,0 +1,49 @@
+import { record } from "../protocol.js";
+export async function activeWorkflow(context, workflowId) {
+    const workflows = await context.authority.queries.workflowIds();
+    const state = await context.authority.state();
+    const queueRun = async (runId) => workflows[runId] === "develop-issue" ||
+        (await context.authority.queries.manifest(runId))?.queue === true;
+    const runs = Object.values(state.runs).filter((run) => !["completed", "failed", "cancelled"].includes(run.status));
+    const own = runs.filter((run) => workflows[run.runId] === workflowId);
+    const queued = workflowId === "develop-issue" ||
+        context.registry.byId(workflowId)?.queue === true ||
+        (await Promise.all(own.map((run) => queueRun(run.runId)))).includes(true);
+    const active = await Promise.all(runs.map(async (run) => {
+        if (workflows[run.runId] !== workflowId &&
+            !(queued && (await queueRun(run.runId))))
+            return undefined;
+        return storedTicket(context, state.details[run.runId]?.input);
+    }));
+    return active.filter((input) => input !== undefined);
+}
+export async function queueOverview(context) {
+    const workflow = context.registry.workflowIds
+        .map((id) => context.registry.byId(id))
+        .find((workflow) => workflow?.admission !== undefined);
+    if (workflow?.admission === undefined)
+        return {};
+    const active = await activeWorkflow(context, workflow.workflowId);
+    return {
+        queue: {
+            lanes: workflow.admission === "when-idle" ? 1 : workflow.admission,
+            busy: active.length,
+            skipped: [
+                ...active.flatMap((input) => typeof input["ticketId"] === "string"
+                    ? [{ ticketId: input["ticketId"], reason: "ticket-active" }]
+                    : []),
+                ...(workflow.resolver.skippedTickets?.() ?? []),
+            ],
+        },
+    };
+}
+async function storedTicket(context, digest) {
+    const text = digest
+        ? await context.authority.queries.document(digest)
+        : undefined;
+    const input = record(JSON.parse(text ?? "null")) ?? {};
+    const ticket = record(record(input["input"])?.["ticket"]);
+    return ticket === undefined
+        ? input
+        : { ...input, ticketId: ticket["id"], ticket: ticket["text"] };
+}

package/dist/src/service/command-effects.d.ts

@@ -0,0 +1,4 @@
+import type { ServiceContext } from "./replies.ts";
+import type { Fields } from "../protocol.ts";
+import type { OperationView } from "../broker/actor/authority.ts";
+export declare function commandFields(context: ServiceContext, operations: readonly OperationView[]): Promise<Fields>;

package/dist/src/service/command-effects.js

@@ -0,0 +1,16 @@
+export async function commandFields(context, operations) {
+    const effects = operations
+        .filter((operation) => operation.capability === "command")
+        .map((operation) => ({
+        operationId: operation.operationId,
+        name: operation.method.slice(4),
+        state: operation.status,
+        exitCode: null,
+        durationMilliseconds: null,
+    }));
+    if (effects.length === 0)
+        return {};
+    return {
+        commandEffects: (await context.commandEffects?.(effects)) ?? effects,
+    };
+}

package/dist/src/service/decision-handler.d.ts

@@ -5,5 +5,9 @@ export declare function feedbackOf(context: ServiceContext, scope: {
     readonly state: StoredState;
     readonly runId: string;
 }): Promise<readonly Fields[]>;
+export declare function decidedOf(context: ServiceContext, scope: {
+    readonly state: StoredState;
+    readonly runId: string;
+}): Promise<readonly Fields[]>;
 export declare function questions(context: ServiceContext, parameters: Fields): Promise<Reply>;
 export declare function decision(context: ServiceContext, parameters: Fields): Promise<Reply>;

package/dist/src/service/decision-handler.js

@@ -1,5 +1,6 @@
-import { continues, gateKey } from "../authority/gates.js";
-import { gateContinuation } from "../authority/reduction.js";
+import { delivers, gateKey } from "../authority/gates.js";
+import { isDeviceActor } from "../authority/commands.js";
+import { gateDelivery } from "../authority/reduction.js";
 import { documentDigest } from "../broker/decision-restore.js";
 import { committed, failed, invalidRequest, isIdentifier, publicReceipt, rejection, result, wholeNumber, } from "./replies.js";
 const decisions = {
@@ -43,6 +44,25 @@ export async function feedbackOf(context, scope) {
     }
     return shown;
 }
+export async function decidedOf(context, scope) {
+    const decided = typed(scope.state).filter((gate) => gate.runId === scope.runId &&
+        gate.outcome !== null &&
+        gate.outcome.decision !== null);
+    const shown = [];
+    for (const gate of decided) {
+        const page = await context.authority.queries.eventsAfter({
+            after: (gate.outcome?.sequence ?? 1) - 1,
+            limit: 1,
+        });
+        const actor = page.events[0]?.payload["actor"];
+        shown.push({
+            decisionId: decisionId(gate),
+            decision: gate.outcome?.decision ?? null,
+            actor: typeof actor === "string" ? actor : "local",
+        });
+    }
+    return shown;
+}
 async function described(context, shown) {
     const { state, gate } = shown;
     const { queries } = context.authority;
@@ -120,7 +140,20 @@ function textLimit(context, command) {
         ? { bytes: feedbackBytes, name: "A feedback text" }
         : { bytes: context.textBytes, name: "An answer" };
 }
+function actorOf(parameters) {
+    const actor = parameters["actor"] ?? null;
+    if (actor === null)
+        return null;
+    return isDeviceActor(actor) ? actor : undefined;
+}
 function decisionRequest(parameters) {
+    const actor = actorOf(parameters);
+    const fields = decisionFields(parameters);
+    if (actor === undefined || fields === undefined)
+        return undefined;
+    return { ...fields, actor };
+}
+function decisionFields(parameters) {
     const { command, reference, expectedRevision, generation } = parameters;
     const { subjectDigest, commandId } = parameters;
     const text = parameters["text"] ?? null;
@@ -183,6 +216,7 @@ export async function decision(context, parameters) {
             generation: request.generation,
             subject: request.subjectDigest,
             ...(text === null ? {} : { answer: documentDigest(text) }),
+            ...(request.actor === null ? {} : { actor: request.actor }),
         },
         documents: text === null ? [] : [text],
     });
@@ -203,9 +237,9 @@ export async function decision(context, parameters) {
 }
 async function continuationState(context, decided) {
     const { gate, run } = decided;
-    if (!continues(gate))
+    if (!delivers(gate))
         return "held";
-    const { operationId } = gateContinuation(gate);
+    const { operationId } = gateDelivery(gate);
     const operation = (await context.authority.operations()).find((item) => item.operationId === operationId);
     if (operation?.deliveries.some((delivery) => delivery.outcome === "sent"))
         return "admitted";
@@ -224,6 +258,7 @@ async function recorded(context, outcome) {
         decisionId: decisionId(gate),
         runId,
         decision: gate.outcome?.decision ?? null,
+        actor: stored.command.actor ?? null,
         commandId,
         replayed: outcome.replayed,
         receipt: publicReceipt(stored),

package/dist/src/service/gateway.js

@@ -1,5 +1,6 @@
 import { invalidCommand, serializable, textList, unserializable, } from "../broker/actor/authority-receipts.js";
 import { record } from "../protocol.js";
+import { commandLimits } from "../command-settings.js";
 export const workerCommandBound = 1_000;
 const permitted = {
     operator: [
@@ -10,6 +11,7 @@ const permitted = {
         "cancel-run",
     ],
     worker: [
+        "record-schedule-skip",
         "mark-started",
         "open-gate",
         "register-wait",
@@ -64,8 +66,17 @@ function refusal(submission, textBytes) {
         };
     return undefined;
 }
+async function reportLimit(parts, submission) {
+    if (submission.command["kind"] !== "report-effect" ||
+        !submission.documents.some((text) => Buffer.byteLength(text) > parts.textBytes))
+        return parts.textBytes;
+    const operation = await parts.authority.effects.operation(String(submission.command["operationId"]));
+    return operation?.capability === "command"
+        ? commandLimits.resultBytes
+        : parts.textBytes;
+}
 export function commandGateway(parts) {
-    const { authority, registry, clock, textBytes } = parts;
+    const { authority, registry, clock } = parts;
     const bound = parts.pendingWorkerCommands ?? workerCommandBound;
     let pending = 0;
     async function manifest(command) {
@@ -74,7 +85,11 @@ export function commandGateway(parts) {
             return registry.byPin(String(command["workflow"]))?.manifest;
         if (!pinned.includes(kind))
             return undefined;
-        const run = (await authority.state()).runs[String(command["runId"])];
+        const runId = String(command["runId"]);
+        const stored = await authority.queries.manifest(runId);
+        if (stored?.bundleDigest !== undefined)
+            return stored;
+        const run = (await authority.state()).runs[runId];
         return registry.byPin(run?.workflow ?? "")?.manifest;
     }
     async function forwarded(submission) {
@@ -109,7 +124,7 @@ export function commandGateway(parts) {
             const submission = checked(given.principal, copy);
             if (submission === undefined)
                 return invalidCommand;
-            const refused = refusal(submission, textBytes);
+            const refused = refusal(submission, await reportLimit(parts, submission));
             if (refused !== undefined)
                 return refused;
             return submission.principal === "worker"

package/dist/src/service/registry.d.ts

@@ -1,6 +1,11 @@
-import type { WorkflowStage, WorkflowStages } from "../workflow-declaration.ts";
+import type { CommandWaits, WorkflowStage, WorkflowStages } from "../workflow-declaration.ts";
 import type { SubmissionContract } from "../submission.ts";
 import type { ExecutionManifest } from "../workflow-admission.ts";
+import type { AvailableManifest } from "../broker/actor/delivery-intents.ts";
+export interface WorkflowBundleStore {
+    readonly directory: string;
+    readonly repository: string;
+}
 export type Resolution = {
     readonly kind: "resolved";
     readonly input: unknown;
@@ -23,6 +28,7 @@ export interface Resolver {
     readonly skippedTickets?: () => readonly Readonly<Record<string, unknown>>[];
 }
 export interface WorkflowRegistration {
+    readonly queue?: boolean;
     readonly workflowId: string;
     readonly manifest: ExecutionManifest;
     readonly availability: "available" | "unavailable";
@@ -31,6 +37,8 @@ export interface WorkflowRegistration {
     readonly effectLimit?: number;
     readonly stages?: readonly WorkflowStage[];
     readonly handoffs?: readonly string[];
+    readonly commands?: readonly string[];
+    readonly commandWaits?: CommandWaits;
     readonly admission?: "when-idle" | number;
 }
 export interface Registered extends WorkflowRegistration {
@@ -41,6 +49,11 @@ export interface Registry {
     readonly workflowStages: WorkflowStages;
     readonly byId: (workflowId: string) => Registered | undefined;
     readonly byPin: (pin: string) => Registered | undefined;
-    readonly available: (pinned: ExecutionManifest) => ExecutionManifest | undefined;
+    readonly bundle: (pinned: ExecutionManifest) => Promise<string | undefined>;
+    readonly available: AvailableManifest;
 }
-export declare function workflowRegistry(workflows: readonly WorkflowRegistration[], retainedWorkflows?: readonly WorkflowRegistration[]): Registry;
+export declare function workflowRegistry(workflows: readonly WorkflowRegistration[], options?: {
+    readonly retainedWorkflows?: readonly WorkflowRegistration[];
+    readonly workflowBundles?: WorkflowBundleStore;
+    readonly retainedWorkflow?: AvailableManifest;
+}): Registry;

package/dist/src/service/registry.js

@@ -1,5 +1,6 @@
 import { workflowPin } from "../broker/workflow-pin.js";
 import { declaredManifest } from "../execution-pin.js";
+import { readRetainedWorkflowBundle } from "../../tools/workflow-bundles.js";
 function registered(workflow) {
     const manifest = declaredManifest(workflow.manifest, workflow);
     return {
@@ -9,10 +10,32 @@ function registered(workflow) {
         pin: workflowPin(manifest),
     };
 }
-export function workflowRegistry(workflows, retainedWorkflows = []) {
+function availableVersions(workflow) {
+    if (workflow.availability !== "available")
+        return [];
+    if (workflow.manifest.bundleDigest === undefined)
+        return [workflow];
+    const manifest = { ...workflow.manifest };
+    delete manifest.bundleDigest;
+    return [workflow, { ...workflow, manifest, pin: workflowPin(manifest) }];
+}
+export function workflowRegistry(workflows, options = {}) {
     const current = workflows.map(registered);
-    const available = [...current, ...retainedWorkflows.map(registered)].filter((workflow) => workflow.availability === "available");
+    const available = [
+        ...current,
+        ...(options.retainedWorkflows ?? []).map(registered),
+    ].flatMap(availableVersions);
     const byPin = (pin) => available.find((workflow) => workflow.pin === pin);
+    const bundle = async (pinned) => {
+        if (pinned.bundleDigest === undefined ||
+            options.workflowBundles === undefined)
+            return undefined;
+        const retained = await readRetainedWorkflowBundle({
+            ...options.workflowBundles,
+            id: pinned.bundleDigest,
+        });
+        return retained.kind === "available" ? retained.directory : undefined;
+    };
     return {
         workflowIds: current.map((workflow) => workflow.workflowId),
         workflowStages: Object.fromEntries(current.flatMap((workflow) => workflow.stages === undefined
@@ -20,6 +43,14 @@ export function workflowRegistry(workflows, retainedWorkflows = []) {
             : [[workflow.workflowId, workflow.stages]])),
         byId: (workflowId) => current.find((workflow) => workflow.workflowId === workflowId),
         byPin,
-        available: (pinned) => byPin(workflowPin(pinned))?.manifest,
+        bundle,
+        available: (pinned) => {
+            const manifest = byPin(workflowPin(pinned))?.manifest;
+            if (pinned.bundleDigest === undefined)
+                return manifest;
+            return bundle(pinned).then((directory) => directory !== undefined
+                ? (manifest ?? options.retainedWorkflow?.(pinned))
+                : undefined);
+        },
     };
 }

package/dist/src/service/replies.d.ts

@@ -3,8 +3,11 @@ import type { Fields, Reply } from "../protocol.ts";
 import type { ChangeSignal } from "./changes.ts";
 import type { Gateway } from "./gateway.ts";
 import type { Registry } from "./registry.ts";
-import type { WorkflowRefusal } from "../workflow-refusals.ts";
+import { type WorkflowRefusal } from "../workflow-refusals.ts";
+import type { CommandEffects } from "../command-settings.ts";
 export interface ServiceContext {
+    readonly workerHarness?: (operationId: string) => Promise<string | undefined>;
+    readonly commandEffects?: CommandEffects;
     readonly authority: Authority;
     readonly registry: Registry;
     readonly workflowRefusals?: readonly WorkflowRefusal[];
@@ -18,6 +21,11 @@ export interface ServiceContext {
     readonly worldReports?: () => readonly unknown[];
     readonly changed?: ChangeSignal["next"];
 }
+export declare function queryMetadata(options: {
+    readonly workerHarness?: ServiceContext["workerHarness"];
+    readonly commandEffects?: CommandEffects;
+    readonly workflowRefusals?: readonly WorkflowRefusal[];
+}): Pick<ServiceContext, "workerHarness" | "commandEffects" | "workflowRefusals">;
 export declare function result(kind: string, fields: Fields): Reply;
 export declare function failed(code: string, extra: Fields): Reply;
 export declare function invalidRequest(detail: string): Reply;

package/dist/src/service/replies.js

@@ -1,4 +1,16 @@
 import { isRecordKey } from "../authority/commands.js";
+import { workflowRefusals, } from "../workflow-refusals.js";
+export function queryMetadata(options) {
+    return {
+        ...(options.workerHarness === undefined
+            ? {}
+            : { workerHarness: options.workerHarness }),
+        ...(options.commandEffects === undefined
+            ? {}
+            : { commandEffects: options.commandEffects }),
+        workflowRefusals: workflowRefusals(options.workflowRefusals),
+    };
+}
 const codes = {
     "invalid-command": "invalid-request",
     "request-too-large": "input-too-large",

package/dist/src/service/run-handlers.js

@@ -1,11 +1,12 @@
-import { issueIdentity } from "../issue-identity.js";
+import { metadataOf, outcomeOf } from "./run-metadata.js";
 import { linksOf } from "../authority/handoff-chain.js";
 import { runView, unresolvedEffects, } from "../authority/status.js";
 import { record } from "../protocol.js";
 import { committed, failed, invalidRequest, isIdentifier, publicReceipt, rejection, result, wholeNumber, } from "./replies.js";
 import { usageTotals } from "./worker-totals.js";
-import { feedbackOf } from "./decision-handler.js";
-import { queueOverview } from "./submission-handler.js";
+import { commandFields } from "./command-effects.js";
+import { decidedOf, feedbackOf } from "./decision-handler.js";
+import { queueOverview } from "./active-tickets.js";
 import { queueRunStatuses } from "./queue-runs.js";
 async function snapshot(context) {
     const { authority } = context;
@@ -44,6 +45,7 @@ async function effectInput(context, runId) {
     const budget = await effects.budget(runId);
     const stored = await effects.operations(runId);
     return {
+        commandOperations: stored.filter((operation) => operation.capability === "command"),
         budget: budget ? { limit: budget.limit, spent: budget.spent } : null,
         effects: stored.map((operation) => ({
             operationId: operation.operationId,
@@ -62,8 +64,9 @@ async function viewOf(context, scope) {
     if (run === undefined)
         return undefined;
     const details = state.details[run.runId];
+    const effects = await effectInput(context, run.runId);
     const input = {
-        ...(await effectInput(context, run.runId)),
+        ...effects,
         closure: run.status === "cancelled"
             ? await context.authority.effects.closure(run.runId)
             : null,
@@ -81,6 +84,7 @@ async function viewOf(context, scope) {
     };
     return {
         ...runView(input),
+        commandOperations: effects.commandOperations,
         ...linksOf({ runId: run.runId, ...scope.snapshot.links[run.runId] }),
         input: await submittedInput(context, details?.submission),
         workflowId: scope.snapshot.workflowIds[run.runId] ?? run.workflow,
@@ -97,6 +101,7 @@ function summary(view) {
         workflowId: view.workflowId,
         state: view.state,
         condition: view.condition,
+        awaitedRunId: view.awaitedRunId,
         revision: view.revision,
         latestSequence: view.latestSequence,
         latestAt: view.latestAt,
@@ -122,57 +127,6 @@ function full(view) {
         feedback: view.feedback,
     };
 }
-async function outcomeOf(context, view) {
-    if (view.state !== "completed")
-        return null;
-    const event = await context.authority.queries.latestCompletion({
-        runId: view.runId,
-        atOrBefore: view.latestSequence,
-    });
-    const payload = event?.payload ?? {};
-    const kind = payload["outcome"];
-    if (kind === undefined)
-        return null;
-    const { ticketStatus, promotionId, outcomeReason, issueUpdate } = payload;
-    return {
-        kind,
-        reason: outcomeReason ?? null,
-        ...(promotionId === undefined ? {} : { promotionId }),
-        ...(ticketStatus === undefined ? {} : { ticketStatus }),
-        ...(issueUpdate === "failed" ? { issueUpdate } : {}),
-    };
-}
-function titleOf(input, workflowId) {
-    const ticket = input?.["ticket"];
-    if (typeof ticket !== "string")
-        return null;
-    const fallback = `Cloving task ${String(input?.["cycleId"])}`;
-    const lines = ticket.split("\n");
-    if (workflowId === "develop-prompt") {
-        const first = lines.find((line) => /\S/.test(line));
-        return first === undefined
-            ? fallback
-            : first.replace(/^# /, "").trim().slice(0, 200);
-    }
-    const first = lines[0] ?? "";
-    return first.startsWith("# ")
-        ? first.slice(2).trim().slice(0, 200)
-        : fallback;
-}
-async function metadataOf(context, source) {
-    const document = source.digest
-        ? await context.authority.queries.document(source.digest)
-        : undefined;
-    const input = record(JSON.parse(document ?? "null"));
-    const ticketId = input?.["ticketId"];
-    return {
-        ticketId: typeof ticketId === "string" && ticketId !== "" ? ticketId : null,
-        title: titleOf(input, source.workflowId),
-        ...(source.workflowId === "develop-issue"
-            ? { issueIdentity: issueIdentity(input?.["ticket"]) }
-            : {}),
-    };
-}
 async function submittedInput(context, digest) {
     const document = digest
         ? await context.authority.queries.document(digest)
@@ -228,7 +182,12 @@ export async function status(context, parameters) {
     return result("run-status", {
         run: {
             ...full({ ...view, ...totals }),
+            ...(await commandFields(context, view.commandOperations)),
             outcome: await outcomeOf(context, view),
+            decisions: await decidedOf(context, {
+                state: current.state,
+                runId: view.runId,
+            }),
             ...(await metadataOf(context, {
                 workflowId: view.workflowId,
                 digest: current.state.details[view.runId]?.input,

package/dist/src/service/run-metadata.d.ts

@@ -0,0 +1,8 @@
+import { type Fields } from "../protocol.ts";
+import type { RunView } from "../authority/status.ts";
+import type { ServiceContext } from "./replies.ts";
+export declare function outcomeOf(context: ServiceContext, view: Pick<RunView, "state" | "runId" | "latestSequence">): Promise<Fields | null>;
+export declare function metadataOf(context: ServiceContext, source: {
+    readonly workflowId: string;
+    readonly digest: string | null | undefined;
+}): Promise<Fields>;