cloving 1.1.0 → 1.3.0

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

@@ -1,13 +1,19 @@
+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 { 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;
     const state = await authority.state();
     const sequences = await authority.queries.sequences();
     return {
+        links: await authority.queries.runLinks(),
         state,
         operations: await authority.operations(),
         sequences: sequences.runs,
@@ -39,9 +45,8 @@ async function effectInput(context, runId) {
     const budget = await effects.budget(runId);
     const stored = await effects.operations(runId);
     return {
-        budget: budget === undefined
-            ? null
-            : { limit: budget.limit, spent: budget.spent },
+        commandOperations: stored.filter((operation) => operation.capability === "command"),
+        budget: budget ? { limit: budget.limit, spent: budget.spent } : null,
         effects: stored.map((operation) => ({
             operationId: operation.operationId,
             status: operation.status,
@@ -59,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,
@@ -78,6 +84,9 @@ 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,
         latestAt: times[run.runId] ?? null,
         unresolvedEffects: unresolvedEffects(input),
@@ -87,9 +96,12 @@ async function viewOf(context, scope) {
 function summary(view) {
     return {
         runId: view.runId,
+        ...linksOf(view),
+        input: view.input,
         workflowId: view.workflowId,
         state: view.state,
         condition: view.condition,
+        awaitedRunId: view.awaitedRunId,
         revision: view.revision,
         latestSequence: view.latestSequence,
         latestAt: view.latestAt,
@@ -115,53 +127,12 @@ 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 kind = event?.payload["outcome"];
-    if (kind === undefined)
-        return null;
-    const ticketStatus = event?.payload["ticketStatus"];
-    return {
-        kind,
-        reason: event?.payload["outcomeReason"] ?? null,
-        ...(ticketStatus === undefined ? {} : { ticketStatus }),
-        ...(event?.payload["issueUpdate"] === "failed"
-            ? { issueUpdate: "failed" }
-            : {}),
-    };
-}
-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)
+async function submittedInput(context, digest) {
+    const document = digest
+        ? await context.authority.queries.document(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),
-    };
+    const request = record(JSON.parse(document ?? "null"));
+    return record(request?.["submission"]) ?? null;
 }
 async function listed(context, page) {
     const identifiers = Object.keys(page.snapshot.state.runs)
@@ -173,21 +144,36 @@ async function listed(context, page) {
         views.push(await viewOf(context, { snapshot: page.snapshot, runId }));
     const runs = views.filter((view) => view !== undefined).map(summary);
     return result("run-list", {
+        ...(await queueOverview(context)),
         workflows: context.registry.workflowIds,
+        workflowRefusals: context.workflowRefusals ?? [],
+        ...(Object.keys(context.registry.workflowStages).length === 0
+            ? {}
+            : {
+                workflowStages: context.registry.workflowStages,
+            }),
         runs,
         next: identifiers.length > shown.length ? (shown.at(-1) ?? null) : null,
         worldReports: context.worldReports?.() ?? [],
     });
 }
-export async function status(context, parameters) {
-    const { runId } = parameters;
+function listParameters(parameters) {
     const after = parameters["after"] ?? "";
     const limit = parameters["limit"] ?? 50;
     if (typeof after !== "string" || !wholeNumber(limit, 1) || limit > 500)
+        return undefined;
+    return { after, limit };
+}
+export async function status(context, parameters) {
+    if (parameters["runIds"] !== undefined)
+        return queueRunStatuses(context, parameters["runIds"]);
+    const { runId } = parameters;
+    const page = listParameters(parameters);
+    if (page === undefined)
         return invalidRequest("The status request is not valid.");
     const current = await snapshot(context);
     if (runId === undefined)
-        return listed(context, { snapshot: current, after, limit });
+        return listed(context, { snapshot: current, ...page });
     const named = typeof runId === "string" ? runId : "";
     const view = await viewOf(context, { snapshot: current, runId: named });
     if (view === undefined)
@@ -196,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>;

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

@@ -0,0 +1,53 @@
+import { issueIdentity } from "../issue-identity.js";
+import { record } from "../protocol.js";
+export 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;
+}
+export 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"]) }
+            : {}),
+    };
+}

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

@@ -0,0 +1,3 @@
+import type { Authority } from "../broker/actor/authority.ts";
+import type { RunWaitTarget } from "../run-wait.ts";
+export declare function runWaitTarget(authority: Authority, runId: string): Promise<RunWaitTarget | undefined>;

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

@@ -0,0 +1,41 @@
+function outcomeOf(event, status) {
+    if (event === undefined)
+        return null;
+    return {
+        kind: event.payload["outcome"] ?? status,
+        reason: event.payload["outcomeReason"] ?? null,
+        promotionId: event.payload["promotionId"] ?? null,
+    };
+}
+async function settled(authority, run) {
+    if (run.status !== "cancelled")
+        return ["completed", "failed"].includes(run.status);
+    const closure = await authority.effects.closure(run.runId);
+    return (!closure.open &&
+        closure.closure === "cancelled" &&
+        closure.unresolved.length === 0);
+}
+export async function runWaitTarget(authority, runId) {
+    const run = await authority.queries.run(runId);
+    const origin = (await authority.queries.runOrigins())[runId];
+    if (run === undefined || origin === undefined)
+        return undefined;
+    const terminal = await settled(authority, run);
+    const event = terminal
+        ? await authority.queries.latestCompletion({
+            runId,
+            atOrBefore: run.sequence,
+            terminal: true,
+        })
+        : undefined;
+    const endedAt = event === undefined ? null : Date.parse(event.recordedAt);
+    const stoppedAt = run.status === "cancelled" && terminal
+        ? await authority.effects.settledAt(runId)
+        : null;
+    return {
+        parentRunId: origin.parentRunId,
+        status: run.status,
+        endedAt: endedAt === null ? null : Math.max(endedAt, stoppedAt ?? endedAt),
+        outcome: outcomeOf(event, run.status),
+    };
+}

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

@@ -1,6 +1,10 @@
 import { type Authority, type AuthorityTiming, type Delivery, type EffectSettings, type Refusal } from "../broker/actor/authority.ts";
-import { type WorkflowRegistration } from "./registry.ts";
+import { type WorkflowRefusal } from "../workflow-refusals.ts";
+import { type Registry, type WorkflowRegistration, type WorkflowBundleStore } from "./registry.ts";
+import { type ServiceContext } from "./replies.ts";
 import { type WorkerPort } from "./worker-port.ts";
+import type { RunWaitTarget } from "../run-wait.ts";
+import type { CommandEffects } from "../command-settings.ts";
 export type { WorkflowRegistration } from "./registry.ts";
 export type { EffectReply, EffectReport, EffectRequest, WorkerPort, } from "./worker-port.ts";
 export interface ServiceTiming {
@@ -23,21 +27,36 @@ export interface ServiceHost {
     readonly reports?: () => readonly unknown[];
 }
 export interface HostPorts {
+    readonly runWait?: {
+        readonly target: (runId: string) => Promise<RunWaitTarget | undefined>;
+        readonly observe: WorkerPort["observe"];
+    };
     readonly state: Authority["state"];
     readonly submit: WorkerPort["submit"];
     readonly input: (runId: string) => Promise<string | undefined>;
     readonly document: (digest: string) => Promise<string | undefined>;
-    readonly workflowId: (runId: string) => Promise<string | undefined>;
+    readonly workflow: {
+        readonly id: (runId: string) => Promise<string | undefined>;
+        readonly manifest: Authority["queries"]["manifest"];
+        readonly available: (runId: string, workflowId?: string) => Promise<boolean>;
+    };
     readonly requestEffect: WorkerPort["requestEffect"];
     readonly operation: Authority["effects"]["operation"];
+    readonly operations: Authority["effects"]["operations"];
     readonly reportEffect: WorkerPort["reportEffect"];
     readonly openGate: WorkerPort["openGate"];
     readonly registerWait: WorkerPort["registerWait"];
 }
 export interface ServiceOptions {
+    readonly workerHarness?: ServiceContext["workerHarness"];
+    readonly commandEffects?: CommandEffects;
     readonly stateDirectory: string;
     readonly runtimeDirectory: string;
     readonly workflows: readonly WorkflowRegistration[];
+    readonly retainedWorkflows?: readonly WorkflowRegistration[];
+    readonly workflowBundles?: WorkflowBundleStore;
+    readonly retainedWorkflow?: Registry["available"];
+    readonly workflowRefusals?: readonly WorkflowRefusal[];
     readonly delivery: Delivery;
     readonly host?: (ports: HostPorts) => Promise<ServiceHost>;
     readonly timing?: ServiceTiming;

package/dist/src/service/service.js

@@ -2,17 +2,19 @@ import { lstat, rm } from "node:fs/promises";
 import { join } from "node:path";
 import { authorityTiming, openAuthority, } from "../broker/actor/authority.js";
 import { socketAddress } from "../broker/socket-address.js";
+import {} from "../workflow-refusals.js";
 import { changeSignal } from "./changes.js";
 import { decision, questions } from "./decision-handler.js";
 import { events } from "./event-handler.js";
 import { expiryScan } from "./expiry.js";
 import { commandGateway, workerCommandBound } from "./gateway.js";
 import { workflowRegistry, } from "./registry.js";
-import { failed } from "./replies.js";
+import { failed, queryMetadata } from "./replies.js";
 import { runCommand, status } from "./run-handlers.js";
 import { submissionHandler } from "./submission-handler.js";
 import { connectionLimits, listen, reachable } from "./transport.js";
 import { workerPort } from "./worker-port.js";
+import { runWaitTarget } from "./run-waits.js";
 export const serviceTiming = {
     authority: authorityTiming,
     expiryScanMilliseconds: 1_000,
@@ -87,6 +89,7 @@ async function started(authority, setup) {
         handle: dispatcher({
             authority,
             registry,
+            ...queryMetadata(options),
             gateway,
             clock,
             changed: changes.next,
@@ -133,7 +136,7 @@ export async function startService(options) {
     if (typeof path !== "string")
         return path;
     const timing = options.timing ?? serviceTiming;
-    const registry = workflowRegistry(options.workflows);
+    const registry = workflowRegistry(options.workflows, options);
     const opening = await openAuthority(options.stateDirectory, {
         delivery: options.delivery,
         timing: timing.authority,
@@ -146,7 +149,7 @@ export async function startService(options) {
     const { authority } = opening;
     const gateway = serviceGateway(authority, { options, registry });
     const worker = workerPort({ gateway, authority });
-    const host = await hosted(options, hostPorts(authority, worker));
+    const host = await hosted(options, hostPorts(authority, { worker, registry }));
     if (host.kind === "refused") {
         await authority.close();
         return host;
@@ -180,8 +183,13 @@ function serviceGateway(authority, parts) {
         pendingWorkerCommands: limits.pendingWorkerCommands,
     });
 }
-function hostPorts(authority, worker) {
+function hostPorts(authority, parts) {
+    const { worker, registry } = parts;
     return {
+        runWait: {
+            target: (runId) => runWaitTarget(authority, runId),
+            observe: worker.observe,
+        },
         state: authority.state,
         submit: worker.submit,
         input: async (runId) => {
@@ -196,7 +204,17 @@ function hostPorts(authority, worker) {
         openGate: worker.openGate,
         registerWait: worker.registerWait,
         operation: authority.effects.operation,
-        workflowId: async (runId) => (await authority.queries.workflowIds())[runId],
+        operations: authority.effects.operations,
+        workflow: {
+            id: async (runId) => (await authority.queries.workflowIds())[runId],
+            manifest: authority.queries.manifest,
+            available: async (runId, workflowId) => {
+                const manifest = await authority.queries.manifest(runId);
+                return (manifest !== undefined &&
+                    (workflowId === undefined || manifest.workflowId === workflowId) &&
+                    (await registry.available(manifest)) !== undefined);
+            },
+        },
     };
 }
 function message(error) {

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

@@ -1,10 +1,13 @@
 import { createHash } from "node:crypto";
+import { handoffChain } from "../authority/handoff-chain.js";
+import { executionCapabilities } from "../execution-pin.js";
 import { setTimeout as delay } from "node:timers/promises";
-import { isIdentifier as isWorkflowIdentifier } from "../authority/commands.js";
+import { isCommandId, isIdentifier as isWorkflowIdentifier, } from "../authority/commands.js";
 import { documentDigest } from "../broker/decision-restore.js";
 import { record } from "../protocol.js";
-import { checkResolution, checkSubmission, normalizedRequest, } from "../submission.js";
-import { committed, failed, invalidRequest, isIdentifier, publicReceipt, rejection, result, } from "./replies.js";
+import { checkResolution, checkSubmission, hasTicketField, normalizedRequest, } from "../submission.js";
+import { activeWorkflow } from "./active-tickets.js";
+import { committed, failed, invalidRequest, publicReceipt, rejection, result, } from "./replies.js";
 export function runIdentity(commandId) {
     return `run-${createHash("sha256").update(commandId).digest("hex").slice(0, 32)}`;
 }
@@ -49,7 +52,7 @@ function effectBudget(workflow) {
         return {};
     return {
         effectLimit: workflow.effectLimit,
-        capabilities: JSON.stringify([...workflow.manifest.capabilities].sort()),
+        capabilities: executionCapabilities(workflow.manifest),
     };
 }
 function usable(workflow, workflowId) {
@@ -73,7 +76,13 @@ async function resolved(context, admission) {
     const { workflow, workflowId, commandId, submission } = admission;
     const limit = new AbortController();
     const timer = new AbortController();
-    const request = { workflowId, submission, commandId, signal: limit.signal };
+    const request = {
+        workflowId,
+        submission,
+        commandId,
+        signal: limit.signal,
+        activeTickets: admission.activeTickets,
+    };
     const call = Promise.resolve(request)
         .then((given) => workflow.resolver.resolve(given))
         .then((value) => checkResolution(value) ?? "failure")
@@ -110,6 +119,9 @@ async function admit(context, admission) {
         return unresolved(context, { kind: resolution, commandId });
     if (resolution.kind === "rejected")
         return failed(resolution.code, { commandId, detail: resolution.detail });
+    const limited = capacityRefusal(workflow, admission);
+    if (limited !== undefined)
+        return limited;
     const { input } = resolution;
     if (Buffer.byteLength(input) > context.documentBytes)
         return unresolved(context, { kind: "failure", commandId });
@@ -124,6 +136,12 @@ async function admit(context, admission) {
             input: documentDigest(input),
             resolver: `${workflow.resolver.id}:${workflow.resolver.version}`,
             ...effectBudget(workflow),
+            ...(admission.chain.kind === "handoff"
+                ? {
+                    parentRunId: admission.chain.parentRunId,
+                    chainId: admission.chain.chainId,
+                }
+                : {}),
         },
         documents: [normalized, input],
     });
@@ -137,9 +155,33 @@ async function admit(context, admission) {
         replayed: receipt.kind === "duplicate",
     });
 }
+function admissionRefusal(workflow, request) {
+    const { workflowId, commandId, submission, activeTickets } = request;
+    const tickets = workflowId === "develop-issue" || hasTicketField(workflow.submission);
+    if (tickets &&
+        typeof submission["ticket"] === "string" &&
+        activeTickets.some((input) => input["ticketId"] === submission["ticket"]))
+        return failed("ticket-active", {
+            commandId,
+            detail: "An active run already works on this ticket.",
+        });
+    if (tickets && submission["ticket"] !== "next")
+        return undefined;
+    return capacityRefusal(workflow, request);
+}
+function capacityRefusal(workflow, request) {
+    if (workflow.admission !== undefined &&
+        request.activeTickets.length >=
+            (workflow.admission === "when-idle" ? 1 : workflow.admission))
+        return failed("workflow-active", {
+            commandId: request.commandId,
+            detail: `The workflow ${request.workflowId} already has an active run.`,
+        });
+    return undefined;
+}
 async function submitted(context, parameters) {
     const { workflowId, commandId } = parameters;
-    if (!isWorkflowIdentifier(workflowId) || !isIdentifier(commandId))
+    if (!isWorkflowIdentifier(workflowId) || !isCommandId(commandId))
         return invalidRequest("The workflow ID or the command ID is not valid.");
     const existing = await context.authority.queries.receipt(commandId);
     if (existing !== undefined)
@@ -147,6 +189,14 @@ async function submitted(context, parameters) {
             workflowId,
             submission: parameters["submission"],
         });
+    const chain = handoffChain(commandId, commandId.startsWith("handoff:")
+        ? await context.authority.queries.runOrigins()
+        : {});
+    if (chain.kind === "refused")
+        return failed(chain.reason, {
+            commandId,
+            detail: "A hand-off chain permits at most five runs and requires a recorded parent.",
+        });
     const found = usable(context.registry.byId(workflowId), workflowId);
     if (found.kind === "unusable")
         return found.reply;
@@ -161,32 +211,33 @@ async function submitted(context, parameters) {
     });
     if (check.kind === "rejected")
         return failed(check.code, { commandId, detail: check.detail });
-    if (found.workflow.admission === "when-idle" &&
-        (await activeWorkflow(context, workflowId)))
-        return failed("workflow-active", {
-            commandId,
-            detail: `The workflow ${workflowId} already has an active run.`,
-        });
+    const activeTickets = await activeWorkflow(context, workflowId);
+    const refusal = admissionRefusal(found.workflow, {
+        workflowId,
+        commandId,
+        submission: check.submission,
+        activeTickets,
+    });
+    if (refusal !== undefined)
+        return refusal;
     return admit(context, {
+        chain,
         workflow: found.workflow,
         workflowId,
         commandId,
         submission: check.submission,
         normalized: check.normalized,
+        activeTickets,
     });
 }
-async function activeWorkflow(context, workflowId) {
-    const workflows = await context.authority.queries.workflowIds();
-    const state = await context.authority.state();
-    return Object.values(state.runs).some((run) => workflows[run.runId] === workflowId &&
-        !["completed", "failed", "cancelled"].includes(run.status));
-}
 export function submissionHandler(context) {
     const pending = new Map();
     return (parameters) => {
         const keys = [`command:${String(parameters["commandId"])}`];
         const workflowId = String(parameters["workflowId"]);
-        if (context.registry.byId(workflowId)?.admission === "when-idle")
+        if (workflowId === "develop-issue" ||
+            hasTicketField(context.registry.byId(workflowId)?.submission) ||
+            context.registry.byId(workflowId)?.admission !== undefined)
             keys.push(`workflow:${workflowId}`);
         const next = () => submitted(context, parameters);
         const previous = keys

package/dist/src/service/worker-port.d.ts

@@ -8,6 +8,7 @@ interface Revised extends Identified {
     readonly expectedRevision: number;
 }
 export interface GateOpening extends Revised {
+    readonly waitMode?: "hook";
     readonly gateId: string;
     readonly kind: "question" | "approval";
     readonly prompt: string;

package/dist/src/service/worker-totals.js

@@ -1,5 +1,5 @@
 import { record } from "../protocol.js";
-import { priceOf, usageOf, workerTotals, } from "../worker-usage.js";
+import { priceOf, usageOf, attemptsOf, workerTotals, } from "../worker-usage.js";
 function reportFields(text) {
     try {
         return record(JSON.parse(text ?? "null")) ?? {};
@@ -17,7 +17,16 @@ export async function usageTotals(context, runId) {
         const report = reportFields(operation.result === null
             ? undefined
             : await queries.document(operation.result));
+        const attempts = attemptsOf(report["attempts"]);
+        const model = report["model"];
+        const summary = report["summary"];
+        const harness = report["harness"] ??
+            (await context.workerHarness?.(operation.operationId));
         turns.push({
+            ...(typeof model === "string" ? { model } : {}),
+            ...(typeof summary === "string" ? { summary } : {}),
+            ...(typeof harness === "string" ? { harness } : {}),
+            ...(attempts === undefined ? {} : { attempts }),
             operationId: operation.operationId,
             usage: usageOf(report["usage"]),
             costUsd: priceOf(report["costUsd"]),

package/dist/src/step-bridge.d.ts

@@ -39,6 +39,35 @@ export interface GateRequest {
     readonly gateId: string;
     readonly kind: "question" | "approval";
     readonly prompt: string;
+    readonly expiresAt?: string;
+}
+export interface DecisionResult {
+    readonly decision: "approved" | "denied" | "answered" | "expired";
+    readonly answer: string | null;
+}
+export type DecisionWait = {
+    readonly token: string;
+} | DecisionResult;
+export type HandoffValue = string | number | boolean | null | readonly HandoffValue[] | {
+    readonly [key: string]: HandoffValue;
+};
+export interface HandoffRequest {
+    readonly workflowId: string;
+    readonly input: Readonly<Record<string, HandoffValue>>;
+}
+export interface RunWaitRequest {
+    readonly runId: string;
+    readonly maximumWaitSeconds: number;
+}
+export interface RunWaitOutcome {
+    readonly kind: string;
+    readonly reason: string | null;
+    readonly promotionId: string | null;
+}
+export interface CommandRequest {
+    readonly scope: ProtectedScope;
+    readonly name: string;
+    readonly input: HandoffValue;
 }
 export type GateResult = {
     readonly kind: "opened";
@@ -53,5 +82,8 @@ export type GateResult = {
 export interface StepBridge {
     readonly effect: (request: ProtectedRequest) => Promise<ProtectedResult>;
     readonly gate: (request: GateRequest) => Promise<GateResult>;
+    readonly waitForDecision?: (request: GateRequest) => Promise<DecisionWait>;
+    readonly handoff?: (request: HandoffRequest) => Promise<ProtectedResult>;
+    readonly waitForRun?: (request: RunWaitRequest) => Promise<RunWaitOutcome>;
 }
 export declare function isStepBridge(value: unknown): value is StepBridge;

package/dist/src/steps/decision-gate.d.ts

@@ -1,2 +1,3 @@
-import { type GateRequest, type GateResult } from "../step-bridge.ts";
+import { type GateRequest, type GateResult, type DecisionWait } from "../step-bridge.ts";
 export declare function decisionGate(request: GateRequest): Promise<GateResult>;
+export declare function openDecisionWait(request: GateRequest): Promise<DecisionWait>;