cloving 1.2.0 → 1.4.0

package/dist/src/daemon/turn-attempts.js

@@ -0,0 +1,166 @@
+import { priceOf, sumUsage, usageOf, } from "../worker-usage.js";
+import { commandModel, replaceCommandModel, estimatedCostUsd, priceForModel, } from "../token-prices.js";
+import { capacityRefusal, retryKind, } from "./claude-turn.js";
+import { nativeHarness } from "../harness-defaults.js";
+import { profileCommand } from "../turn-profile.js";
+export function total(values) {
+    if (values.includes(null))
+        return null;
+    return priceOf(values.reduce((sum, value) => sum + (value ?? 0), 0));
+}
+export function combined(attempts) {
+    const { ends } = attempts;
+    const last = ends.at(-1) ?? { exitCode: null, result: undefined };
+    const result = last.result ?? ends.find((end) => end.result)?.result;
+    if (result === undefined)
+        return last;
+    return {
+        ...last,
+        result: {
+            ...result,
+            attempts: ends.map((end, index) => attemptUsage(attempts, { end, attempt: index + 1 })),
+            ...(last.result === undefined ? { failed: true, text: "" } : {}),
+            usage: sumUsage(ends.map((end) => end.result?.usage ?? usageOf(null))),
+            costUsd: (attempts.start.worker ?? "claude") === "claude"
+                ? sessionCost(ends)
+                : total(ends.map((end) => end.result?.costUsd ?? null)),
+            turns: total(ends.map((end) => end.result?.turns ?? null)),
+        },
+    };
+}
+function selectedCommand(attempts, attempt) {
+    const { start, options } = attempts;
+    const original = start.command;
+    const previous = attempts.ends[attempt - 2];
+    if (options.resume !== undefined &&
+        attempt === options.resume.ends.length + 1) {
+        const model = previous?.result?.model;
+        return {
+            command: model == null ? original : replaceCommandModel(original, model),
+            fallback: undefined,
+        };
+    }
+    const ordinal = attempt -
+        attempts.ends
+            .slice(0, attempt - 1)
+            .filter((end) => end.resumedAfter !== undefined).length;
+    const fallback = previous !== undefined && kindOf(attempts, previous) === "capacity"
+        ? options.fallbackModels?.[ordinal - 3]
+        : undefined;
+    return {
+        command: fallback === undefined
+            ? original
+            : replaceCommandModel(original, fallback),
+        fallback,
+    };
+}
+export function attemptCommand(attempts, attempt) {
+    const { start } = attempts;
+    const { command: selected, fallback } = selectedCommand(attempts, attempt);
+    const budgetUsd = remainingBudget(attempts);
+    const command = budgetUsd === undefined
+        ? selected
+        : profileCommand(selected, { maxBudgetUsd: budgetUsd });
+    const model = start.output === "text" ? null : commandModel(command);
+    return {
+        command,
+        ...(budgetUsd === undefined ? {} : { budgetUsd }),
+        model,
+        ...(fallback !== undefined && model === null
+            ? { fallbackReason: "fallback-model-unavailable" }
+            : {}),
+    };
+}
+export function attemptUsage(attempts, completion) {
+    const { end, attempt } = completion;
+    const result = end.result ?? {
+        model: null,
+        usage: usageOf(null),
+        costUsd: null,
+        pricingModel: undefined,
+    };
+    const model = result.model ?? attemptCommand(attempts, attempt).model;
+    const usage = result.usage;
+    return {
+        attempt,
+        ...(end.resumedAfter === undefined
+            ? {}
+            : { resumedAfter: end.resumedAfter }),
+        retryKind: kindOf(attempts, end),
+        model,
+        ...(end.result?.models === undefined ? {} : { models: end.result.models }),
+        usage,
+        costUsd: (attempts.start.worker ?? "claude") === "claude"
+            ? attemptCost(attempts.ends, attempt - 1)
+            : result.costUsd,
+        estimatedCostUsd: attemptEstimate(attempts, { end, model, usage }),
+    };
+}
+export function sessionCost(ends) {
+    const sessions = new Map();
+    ends.forEach((end, index) => {
+        sessions.set(end.result?.sessionId ?? index, end.result?.costUsd ?? null);
+    });
+    return total([...sessions.values()]);
+}
+export function attemptCost(ends, index) {
+    const result = ends[index]?.result;
+    if (result?.costUsd == null)
+        return null;
+    const earlier = result.sessionId === null
+        ? undefined
+        : ends
+            .slice(0, index)
+            .findLast((end) => end.result?.sessionId === result.sessionId);
+    if (earlier === undefined)
+        return result.costUsd;
+    const cost = earlier.result?.costUsd;
+    return cost == null
+        ? null
+        : priceOf(Number((result.costUsd - cost).toFixed(12)));
+}
+function remainingBudget(attempts) {
+    if ((attempts.start.worker ?? "claude") !== "claude" ||
+        attempts.start.output === "text")
+        return undefined;
+    const budget = commandBudget(attempts.start.command);
+    if (budget === undefined)
+        return undefined;
+    const spent = sessionCost(attempts.ends);
+    return Math.max(0, Number((budget - (spent ?? 0)).toFixed(12)));
+}
+function commandBudget(original) {
+    const separator = original.indexOf("--");
+    const command = separator < 0 ? original : original.slice(0, separator);
+    const index = command.findLastIndex((part) => part === "--max-budget-usd" || part.startsWith("--max-budget-usd="));
+    if (index < 0)
+        return undefined;
+    const argument = command[index] ?? "";
+    const budget = Number(argument.includes("=") ? argument.split("=")[1] : command[index + 1]);
+    if (!Number.isFinite(budget) || budget < 0)
+        return undefined;
+    return budget;
+}
+export function attemptEstimate(attempts, result) {
+    const worker = attempts.start.worker ?? "claude";
+    if (!nativeHarness(worker))
+        return null;
+    const models = result.end.result?.models;
+    const prices = attempts.options.tokenPrices ?? {};
+    return estimatedCostUsd(result.usage, worker === "gemini" && models !== undefined
+        ? { worker, models, prices }
+        : {
+            worker,
+            price: priceForModel(prices, result.end.result?.pricingModel === undefined
+                ? result.model
+                : result.end.result.pricingModel),
+        });
+}
+export function kindOf(attempts, end) {
+    const { worker, output } = attempts.start;
+    if (output === "text" || !["claude", "codex"].includes(worker ?? "claude"))
+        return null;
+    if (worker !== "codex")
+        return end.retryKind ?? retryKind(end.result);
+    return capacityRefusal(end.result) ? "capacity" : null;
+}

package/dist/src/daemon/turn-command.d.ts

@@ -0,0 +1,10 @@
+export interface CommandStart {
+    readonly output?: string | undefined;
+    readonly worker?: string | undefined;
+    readonly command: readonly string[];
+    readonly prompt: string;
+}
+export declare function turnCommand(start: CommandStart): {
+    readonly parts: readonly string[];
+    readonly standardInput: string | undefined;
+};

package/dist/src/daemon/turn-command.js

@@ -0,0 +1,33 @@
+function argumentPrompt(prompt) {
+    return Buffer.byteLength(prompt, "utf8") < 64 * 1024;
+}
+export function turnCommand(start) {
+    if (start.output === "text")
+        return {
+            parts: start.command.map((part) => part === "{prompt}" ? start.prompt : part),
+            standardInput: start.command.includes("{prompt}")
+                ? undefined
+                : start.prompt,
+        };
+    if (start.worker === "gemini" && argumentPrompt(start.prompt))
+        return {
+            parts: [...start.command, "-p", start.prompt],
+            standardInput: undefined,
+        };
+    if (start.worker === "opencode")
+        return {
+            parts: [...start.command, start.prompt],
+            standardInput: undefined,
+        };
+    if (start.worker === "cursor-agent" && argumentPrompt(start.prompt))
+        return {
+            parts: [...start.command, start.prompt],
+            standardInput: undefined,
+        };
+    if (start.worker !== "grok")
+        return { parts: start.command, standardInput: start.prompt };
+    const command = [...start.command];
+    const index = command.findIndex((argument, position) => position > 0 && ["-p", "--single"].includes(argument));
+    command.splice(index < 0 ? command.length : index + 1, 0, start.prompt);
+    return { parts: command, standardInput: undefined };
+}

package/dist/src/daemon/turn-report.d.ts

@@ -0,0 +1,25 @@
+import type { Recorded } from "./operation-journal.ts";
+import { type WorkTree } from "./work-tree.ts";
+import { type StreamResult, type TurnEnd } from "./claude-turn.ts";
+interface ReportLimits {
+    readonly summaryCharacters: number;
+    readonly resultBytes: number;
+}
+export declare function turnReport(start: {
+    readonly harness: {
+        readonly worker: string;
+        readonly output?: "text";
+    };
+    readonly tree: WorkTree;
+    readonly limits: ReportLimits;
+}, result: StreamResult): Promise<{
+    readonly text?: string;
+    readonly reason?: string;
+}>;
+export declare function turnOutcome(running: Parameters<typeof turnReport>[0] & {
+    readonly stopping: {
+        readonly requested: boolean;
+        readonly stoppedBy?: "daemon-shutdown";
+    };
+}, end: TurnEnd): Promise<Recorded>;
+export {};

package/dist/src/daemon/turn-report.js

@@ -0,0 +1,118 @@
+import { ticketStatus } from "../ticket-status.js";
+import { reviewReport } from "../review-subject.js";
+import { sumPrices } from "../worker-usage.js";
+import { changes } from "./work-tree.js";
+import { succeeded } from "./claude-turn.js";
+function tailReport(fields, limit) {
+    let text = JSON.stringify({ ...fields, summary: "" });
+    if (Buffer.byteLength(text) > limit)
+        return undefined;
+    let minimum = 1;
+    let maximum = fields.summary.length;
+    while (minimum <= maximum) {
+        const kept = Math.floor((minimum + maximum) / 2);
+        const candidate = JSON.stringify({
+            ...fields,
+            summary: fields.summary.slice(-kept),
+        });
+        if (Buffer.byteLength(candidate) > limit) {
+            maximum = kept - 1;
+            continue;
+        }
+        text = candidate;
+        minimum = kept + 1;
+    }
+    return text;
+}
+function boundedReport(fields, options) {
+    const text = JSON.stringify(fields);
+    const excess = Buffer.byteLength(text) - options.limit;
+    if (excess <= 0)
+        return { text };
+    if (options.output === "text") {
+        const shortened = tailReport(fields, options.limit);
+        return shortened === undefined
+            ? { reason: "claude-result-too-large" }
+            : { text: shortened };
+    }
+    const kept = Math.max(0, fields.summary.length - excess);
+    const shortened = JSON.stringify({
+        ...fields,
+        summary: fields.summary.slice(0, kept),
+    });
+    if (Buffer.byteLength(shortened) <= options.limit)
+        return { text: shortened };
+    const metadata = JSON.stringify({
+        ...fields,
+        ticketStatus: undefined,
+        summary: "",
+    });
+    return {
+        reason: "claude-result-too-large",
+        ...(Buffer.byteLength(metadata) <= options.limit ? { text: metadata } : {}),
+    };
+}
+export async function turnReport(start, result) {
+    if (result.ticketStatusTooLarge === true)
+        return { reason: "claude-result-too-large" };
+    const { harness, tree, limits } = start;
+    const review = reviewReport(result.text);
+    const feedback = result.reviewFeedback ?? review.feedback;
+    return boundedReport({
+        harness: harness.worker,
+        ticketStatus: ticketStatus(result.text, result.ticketStatus),
+        reviewVerdict: result.reviewVerdict === undefined
+            ? review.reviewVerdict
+            : result.reviewVerdict,
+        summary: harness.output === "text"
+            ? feedback.slice(-limits.summaryCharacters)
+            : feedback.slice(0, limits.summaryCharacters),
+        ...(await changes(tree)),
+        worktree: tree.path,
+        costUsd: result.costUsd,
+        usage: result.usage,
+        model: result.model,
+        ...(result.attempts === undefined ? {} : { attempts: result.attempts }),
+        estimatedCostUsd: sumPrices((result.attempts ?? []).map((attempt) => attempt.estimatedCostUsd)),
+        sessionId: result.sessionId,
+        turns: result.turns,
+    }, { ...harness, limit: limits.resultBytes });
+}
+export async function turnOutcome(running, end) {
+    const endedAt = new Date().toISOString();
+    if (end.stopped === true && running.stopping.stoppedBy === "daemon-shutdown")
+        return stoppedOutcome(running.stopping, endedAt);
+    const { result } = end;
+    const report = result === undefined
+        ? {}
+        : await turnReport({
+            tree: running.tree,
+            harness: running.harness,
+            limits: running.limits,
+        }, result);
+    const { text, reason } = report;
+    if (succeeded(end) && reason === undefined && text !== undefined)
+        return { outcome: "completed", result: text, endedAt };
+    if (running.stopping.requested)
+        return stoppedOutcome(running.stopping, endedAt);
+    return failedOutcome(end, { ...report, endedAt });
+}
+function failedOutcome(end, report) {
+    const { text, reason, endedAt } = report;
+    return {
+        outcome: "failed",
+        reason: end.reason ?? reason ?? "claude-turn-failed",
+        ...(end.detail === undefined ? {} : { detail: end.detail }),
+        ...(text === undefined ? {} : { result: text }),
+        endedAt,
+    };
+}
+function stoppedOutcome(stopping, endedAt) {
+    return {
+        outcome: "stopped",
+        endedAt,
+        ...(stopping.stoppedBy === undefined
+            ? {}
+            : { stoppedBy: stopping.stoppedBy }),
+    };
+}

package/dist/src/daemon/work-tree.d.ts

@@ -12,9 +12,10 @@ export interface TreeRequest {
 }
 export interface Changes {
     readonly branch: string;
+    readonly commit: string | null;
     readonly commits: readonly string[];
     readonly files: readonly string[];
-    readonly uncommitted: readonly string[];
+    readonly uncommitted: readonly string[] | null;
 }
 export declare function treeName(target: string): string;
 export declare function treePlace(request: Pick<TreeRequest, "worktrees" | "target">): {
@@ -24,3 +25,12 @@ export declare function treePlace(request: Pick<TreeRequest, "worktrees" | "targ
 export declare function workTree(request: TreeRequest): Promise<WorkTree>;
 export declare function treeFailure(error: unknown): string;
 export declare function changes(tree: WorkTree): Promise<Changes>;
+export declare function firstTurn(settings: {
+    readonly journal: string;
+}, opening: {
+    readonly tree: WorkTree;
+    readonly intent: {
+        readonly target: string;
+        readonly runId: string;
+    };
+}): Promise<WorkTree>;

package/dist/src/daemon/work-tree.js

@@ -1,3 +1,4 @@
+import { readRecord, writeRecord, operationKey } from "./operation-journal.js";
 import { execFile, spawn } from "node:child_process";
 import { existsSync } from "node:fs";
 import { mkdir, realpath } from "node:fs/promises";
@@ -186,21 +187,43 @@ export function treeFailure(error) {
         : "work-tree-not-available";
 }
 export async function changes(tree) {
-    const lines = async (parts) => (await git({ directory: tree.path, parts }).catch(() => ""))
-        .split("\n")
-        .filter((line) => line.trim() !== "")
-        .slice(0, lineLimit)
-        .map((line) => line.slice(0, lineLength));
+    const lines = (parts) => changeLines({ directory: tree.path, parts });
     const range = `${tree.startCommit}..HEAD`;
-    const [branch = tree.branch] = await lines([
-        "rev-parse",
-        "--abbrev-ref",
-        "HEAD",
-    ]);
+    const branch = (await lines(["rev-parse", "--abbrev-ref", "HEAD"]))?.[0] ?? tree.branch;
     return {
         branch,
-        commits: await lines(["log", "--oneline", range]),
-        files: await lines(["diff", "--stat", range]),
+        commit: (await lines(["rev-parse", "HEAD"]))?.[0] ?? null,
+        commits: (await lines(["log", "--oneline", range])) ?? [],
+        files: (await lines(["diff", "--stat", range])) ?? [],
         uncommitted: await lines(["status", "--short"]),
     };
 }
+async function changeLines(call) {
+    const output = await git(call).catch(() => null);
+    if (output === null)
+        return null;
+    return output
+        .split("\n")
+        .filter((line) => line.trim() !== "")
+        .slice(0, lineLimit)
+        .map((line) => line.slice(0, lineLength));
+}
+export async function firstTurn(settings, opening) {
+    const { tree, intent } = opening;
+    const { target, runId } = intent;
+    const folder = target.startsWith("branch:")
+        ? join(settings.journal, "runs", operationKey(runId), "targets")
+        : join(settings.journal, "targets");
+    const name = `${operationKey(target)}.json`;
+    const record = await readRecord(folder, name);
+    const startCommit = typeof record === "object" && record !== null
+        ? Reflect.get(record, "startCommit")
+        : undefined;
+    if (typeof startCommit === "string")
+        return { ...tree, startCommit };
+    await writeRecord(folder, {
+        name,
+        value: { target, startCommit: tree.startCommit },
+    });
+    return tree;
+}

package/dist/src/daemon/worker-profile.d.ts

@@ -0,0 +1,8 @@
+import { type HarnessSettings } from "../harness-defaults.ts";
+import type { TurnProfile, TurnProfiles } from "../turn-profile.ts";
+import type { ProtectedIntent } from "../broker/actor/delivery-intents.ts";
+export interface WorkerProfiles extends HarnessSettings {
+    readonly profiles?: TurnProfiles;
+    readonly workflowId?: (runId: string) => Promise<string | undefined>;
+}
+export declare function selectedProfile(settings: WorkerProfiles, intent: ProtectedIntent): Promise<TurnProfile | string>;

package/dist/src/daemon/worker-profile.js

@@ -0,0 +1,40 @@
+import { turnHarness } from "../harness-defaults.js";
+async function runWorkflow(settings, runId) {
+    try {
+        return await settings.workflowId?.(runId);
+    }
+    catch {
+        return undefined;
+    }
+}
+function unsupportedProfile(profile, harness) {
+    if (harness.output === "text" && profile.model !== undefined)
+        return "profile-model-not-supported";
+    if (harness.worker === "claude")
+        return undefined;
+    return [
+        profile.allowedTools,
+        profile.permissionMode,
+        profile.maxBudgetUsd,
+    ].some((value) => value !== undefined)
+        ? "profile-needs-claude"
+        : undefined;
+}
+export async function selectedProfile(settings, intent) {
+    if (intent.method === "run-turn")
+        return {};
+    const name = intent.method.slice("run-turn:".length);
+    const profiles = settings.profiles ?? {};
+    const profile = Object.hasOwn(profiles, name) ? profiles[name] : undefined;
+    if (profile === undefined)
+        return "unknown-profile";
+    const unsupported = unsupportedProfile(profile, turnHarness(settings, profile));
+    if (unsupported !== undefined)
+        return unsupported;
+    if (profile.workflows === undefined)
+        return profile;
+    const workflowId = await runWorkflow(settings, intent.runId);
+    if (workflowId === undefined || !profile.workflows.includes(workflowId))
+        return "profile-not-allowed";
+    return profile;
+}

package/dist/src/daemon/workflow-generations.d.ts

@@ -0,0 +1,32 @@
+import type { HostPorts } from "../service/service.ts";
+import type { WorkflowFunction } from "../host/start-delivery.ts";
+import type { WorkflowHandler } from "../host/world-host.ts";
+import type { ExecutionManifest } from "../workflow-admission.ts";
+import { type WorkflowRegistration } from "../service/registry.ts";
+export interface WorkflowGeneration {
+    readonly workflows: Readonly<Record<string, unknown>>;
+    readonly handler: WorkflowHandler;
+}
+export type WorkflowBundleLoader = (directory: string) => Promise<WorkflowGeneration>;
+export declare function workflowGenerations(settings: {
+    readonly directory: string;
+    readonly repository: string;
+    readonly registrations: readonly WorkflowRegistration[];
+    readonly table: readonly {
+        readonly workflowId: string;
+        readonly functionName: string;
+    }[];
+    readonly workflows: Readonly<Record<string, WorkflowFunction | undefined>>;
+    readonly handler: WorkflowHandler;
+    readonly loadBundle?: WorkflowBundleLoader;
+}): {
+    resolve: (manifest: ExecutionManifest | undefined) => Promise<{
+        workflow: WorkflowFunction;
+        handler: WorkflowHandler;
+    } | undefined>;
+    available: (manifest: ExecutionManifest) => Promise<ExecutionManifest | undefined>;
+};
+export declare function prepareWorkflowGenerations(ports: {
+    readonly state: HostPorts["state"];
+    readonly workflow: Pick<HostPorts["workflow"], "manifest">;
+}, generations: Pick<ReturnType<typeof workflowGenerations>, "resolve">): Promise<void>;

package/dist/src/daemon/workflow-generations.js

@@ -0,0 +1,57 @@
+import { join } from "node:path";
+import { workflowRegistry, } from "../service/registry.js";
+import { workflowPin } from "../broker/workflow-pin.js";
+export function workflowGenerations(settings) {
+    const functions = Object.fromEntries(settings.table.map((row) => [
+        row.workflowId,
+        settings.workflows[row.functionName],
+    ]));
+    const registry = workflowRegistry(settings.registrations, {
+        workflowBundles: {
+            directory: join(settings.directory, "workflow-bundles"),
+            repository: settings.repository,
+        },
+    });
+    const resolve = async (manifest) => {
+        if (manifest === undefined)
+            return undefined;
+        const registered = registry.byPin(workflowPin(manifest));
+        if (registered !== undefined) {
+            const workflow = functions[registered.workflowId];
+            return workflow === undefined
+                ? undefined
+                : { workflow, handler: settings.handler };
+        }
+        if (manifest.bundleDigest === undefined ||
+            settings.loadBundle === undefined)
+            return undefined;
+        const directory = await registry.bundle(manifest);
+        if (directory === undefined)
+            return undefined;
+        try {
+            const generation = await settings.loadBundle(directory);
+            const workflow = Object.values(generation.workflows).find((candidate) => typeof candidate === "function" &&
+                Reflect.get(candidate, "workflowId") === manifest.workflowId);
+            return workflow === undefined
+                ? undefined
+                : { workflow, handler: generation.handler };
+        }
+        catch {
+            return undefined;
+        }
+    };
+    return {
+        resolve,
+        available: async (manifest) => (await resolve(manifest)) === undefined ? undefined : manifest,
+    };
+}
+export async function prepareWorkflowGenerations(ports, generations) {
+    const prepared = new Set();
+    for (const run of Object.values((await ports.state()).runs)) {
+        if (["completed", "failed", "cancelled"].includes(run.status) ||
+            prepared.has(run.workflow))
+            continue;
+        prepared.add(run.workflow);
+        await generations.resolve(await ports.workflow.manifest(run.runId));
+    }
+}

package/dist/src/daemon/workflow-replay.d.ts

@@ -0,0 +1,16 @@
+import type { WorkflowHandler } from "../host/world-host.ts";
+import type { AuthorityState } from "../authority/transitions.ts";
+interface ReplayRun {
+    readonly runId: string;
+    readonly workflowId?: string;
+}
+interface ReplayPorts {
+    readonly state: () => Promise<Pick<AuthorityState, "details">>;
+    readonly run: (receipt: string) => Promise<ReplayRun | undefined>;
+    readonly available: (runId: string, workflowId?: string) => Promise<boolean>;
+    readonly submit: (command: Readonly<Record<string, unknown>>) => Promise<{
+        readonly kind: "accepted" | "duplicate" | "failed" | "rejected";
+    }>;
+}
+export declare function pinnedWorkflowHandler(handler: (request: Request, runId: string) => Promise<Response>, ports: ReplayPorts): WorkflowHandler;
+export {};

package/dist/src/daemon/workflow-replay.js

@@ -0,0 +1,58 @@
+import { record } from "../protocol.js";
+import { setTimeout as delay } from "node:timers/promises";
+function seeded(value) {
+    const input = record(record(value)?.["runInput"]);
+    const runId = record(input?.["attributes"])?.["cloving.run"];
+    const workflowId = input?.["workflowName"];
+    return typeof runId === "string" && typeof workflowId === "string"
+        ? { runId, workflowId }
+        : undefined;
+}
+async function located(ports, receipt) {
+    for (let attempt = 0; attempt < 20; attempt += 1) {
+        const run = await ports.run(receipt);
+        if (run !== undefined)
+            return run;
+        await delay(5);
+    }
+    return undefined;
+}
+async function observedReplay(ports, replay) {
+    const { runId, receipt, available } = replay;
+    const observation = (await ports.state()).details[runId]?.observation;
+    const unavailable = observation?.reason === "pinned-workflow-unavailable";
+    if (available !== unavailable)
+        return true;
+    const expectedObservation = observation?.sequence ?? 0;
+    const outcome = await ports.submit({
+        kind: "report-observation",
+        runId,
+        commandId: `pinned-workflow-${available ? "restored" : "unavailable"}:${receipt}:${String(expectedObservation)}`,
+        condition: available ? "working" : "infrastructure-failure",
+        reason: available ? "in-progress" : "pinned-workflow-unavailable",
+        expectedObservation,
+    });
+    return outcome.kind === "accepted" || outcome.kind === "duplicate";
+}
+export function pinnedWorkflowHandler(handler, ports) {
+    return async (request) => {
+        const value = await request
+            .clone()
+            .json()
+            .catch(() => undefined);
+        const receipt = record(value)?.["runId"];
+        if (typeof receipt !== "string")
+            return new Response("invalid-workflow-message", { status: 400 });
+        const run = (await ports.run(receipt)) ??
+            seeded(value) ??
+            (await located(ports, receipt));
+        if (run === undefined)
+            return new Response("unknown-world-run", { status: 503 });
+        const available = await ports.available(run.runId, run.workflowId);
+        if (!(await observedReplay(ports, { runId: run.runId, receipt, available })))
+            return new Response("workflow-observation-unavailable", { status: 503 });
+        if (available)
+            return handler(request, run.runId);
+        return new Response("pinned-workflow-unavailable", { status: 503 });
+    };
+}