cloving 1.3.0 → 1.5.0

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

@@ -0,0 +1,33 @@
+import { stat } from "node:fs/promises";
+import { join } from "node:path";
+import { located } from "./operation-journal.js";
+import { archiveFolder } from "./record-sweep.js";
+import { turnDetails, } from "../record-retention.js";
+function absent(error) {
+    return error instanceof Error && "code" in error && error.code === "ENOENT";
+}
+async function present(journal, operationIds) {
+    const found = await Promise.all(operationIds.map((operationId) => stat(located(journal, operationId).folder).then(() => true, (error) => (absent(error) ? false : undefined))));
+    if (found.includes(undefined))
+        return undefined;
+    return found.filter(Boolean).length;
+}
+export function turnDetailsPlace(settings) {
+    return async ({ runId, operationIds }) => {
+        const archive = join(archiveFolder(settings), "journal");
+        const runs = await settings.runs([runId]);
+        const archived = await present(archive, operationIds);
+        const kept = await present(join(settings.directory, "journal"), operationIds);
+        if (archived === undefined || kept === undefined)
+            return undefined;
+        return turnDetails({
+            turns: operationIds.length,
+            kept,
+            archived: archived === 0 ? undefined : archive,
+        }, {
+            run: Object.hasOwn(runs, runId) ? runs[runId] : undefined,
+            retention: settings.retention,
+            now: settings.now(),
+        });
+    };
+}

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

@@ -1,5 +1,6 @@
+import type { Recorded } from "./operation-journal.ts";
 import { type WorkTree } from "./work-tree.ts";
-import type { StreamResult } from "./claude-turn.ts";
+import { type StreamResult, type TurnEnd } from "./claude-turn.ts";
 interface ReportLimits {
     readonly summaryCharacters: number;
     readonly resultBytes: number;
@@ -15,4 +16,10 @@ export declare function turnReport(start: {
     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

@@ -2,6 +2,7 @@ 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)
@@ -77,3 +78,41 @@ export async function turnReport(start, result) {
         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

@@ -25,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";
@@ -207,3 +208,22 @@ async function changeLines(call) {
         .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,9 @@
+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 checkedProfiles(settings: HarnessSettings, profiles: TurnProfiles): void;
+export declare function selectedProfile(settings: WorkerProfiles, intent: ProtectedIntent): Promise<TurnProfile | string>;

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

@@ -0,0 +1,44 @@
+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 function checkedProfiles(settings, profiles) {
+    for (const profile of Object.values(profiles))
+        turnHarness(settings, profile);
+}
+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

@@ -8,16 +8,18 @@ export interface WorkflowGeneration {
     readonly handler: WorkflowHandler;
 }
 export type WorkflowBundleLoader = (directory: string) => Promise<WorkflowGeneration>;
-export declare function workflowGenerations(settings: {
-    readonly directory: string;
-    readonly repository: string;
+export interface CurrentGeneration {
     readonly registrations: readonly WorkflowRegistration[];
     readonly table: readonly {
         readonly workflowId: string;
         readonly functionName: string;
     }[];
-    readonly workflows: Readonly<Record<string, WorkflowFunction | undefined>>;
+    readonly workflows: Readonly<Record<string, unknown>>;
     readonly handler: WorkflowHandler;
+}
+export declare function workflowGenerations(settings: CurrentGeneration & {
+    readonly directory: string;
+    readonly repository: string;
     readonly loadBundle?: WorkflowBundleLoader;
 }): {
     resolve: (manifest: ExecutionManifest | undefined) => Promise<{
@@ -25,6 +27,7 @@ export declare function workflowGenerations(settings: {
         handler: WorkflowHandler;
     } | undefined>;
     available: (manifest: ExecutionManifest) => Promise<ExecutionManifest | undefined>;
+    replace: (source: CurrentGeneration) => void;
 };
 export declare function prepareWorkflowGenerations(ports: {
     readonly state: HostPorts["state"];

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

@@ -1,26 +1,31 @@
 import { join } from "node:path";
 import { workflowRegistry, } from "../service/registry.js";
 import { workflowPin } from "../broker/workflow-pin.js";
+function isWorkflowFunction(value) {
+    return typeof value === "function";
+}
 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 workflowBundles = {
+        directory: join(settings.directory, "workflow-bundles"),
+        repository: settings.repository,
+    };
+    const generation = (source) => ({
+        functions: new Map(source.table.map((row) => [
+            row.workflowId,
+            source.workflows[row.functionName],
+        ])),
+        registry: workflowRegistry(source.registrations, { workflowBundles }),
+        handler: source.handler,
     });
+    let current = generation(settings);
     const resolve = async (manifest) => {
         if (manifest === undefined)
             return undefined;
+        const { functions, registry, handler } = current;
         const registered = registry.byPin(workflowPin(manifest));
         if (registered !== undefined) {
-            const workflow = functions[registered.workflowId];
-            return workflow === undefined
-                ? undefined
-                : { workflow, handler: settings.handler };
+            const workflow = functions.get(registered.workflowId);
+            return isWorkflowFunction(workflow) ? { workflow, handler } : undefined;
         }
         if (manifest.bundleDigest === undefined ||
             settings.loadBundle === undefined)
@@ -30,7 +35,7 @@ export function workflowGenerations(settings) {
             return undefined;
         try {
             const generation = await settings.loadBundle(directory);
-            const workflow = Object.values(generation.workflows).find((candidate) => typeof candidate === "function" &&
+            const workflow = Object.values(generation.workflows).find((candidate) => isWorkflowFunction(candidate) &&
                 Reflect.get(candidate, "workflowId") === manifest.workflowId);
             return workflow === undefined
                 ? undefined
@@ -43,6 +48,9 @@ export function workflowGenerations(settings) {
     return {
         resolve,
         available: async (manifest) => (await resolve(manifest)) === undefined ? undefined : manifest,
+        replace: (source) => {
+            current = generation(source);
+        },
     };
 }
 export async function prepareWorkflowGenerations(ports, generations) {

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

@@ -0,0 +1,41 @@
+import type { WorkflowReloadPort } from "../service/workflow-reload.ts";
+import { type DeclaredWorkflow } from "../workflow-declaration.ts";
+import type { DaemonSettings } from "./daemon-adapters.ts";
+import type { WorkflowBundleLoader, workflowGenerations } from "./workflow-generations.ts";
+import { type TurnSettingsSource } from "./settings-reload.ts";
+export declare function queueWorkflowId(settings: {
+    readonly declarations?: readonly DeclaredWorkflow[];
+}): string | undefined;
+export declare function daemonRegistrations(settings: DaemonSettings): Promise<{
+    table: readonly import("./ticket-registration.ts").TicketRegistration[];
+    admitted: {
+        readonly kind: "rejected";
+        readonly detail: string;
+    } | {
+        registrations: {
+            admission?: "when-idle" | number;
+            queue?: boolean;
+            workflowId: string;
+            manifest: import("../workflow-admission.ts").ExecutionManifest;
+            availability: "available" | "unavailable";
+            submission: import("../submission.ts").SubmissionContract;
+            resolver: import("../service/registry.ts").Resolver;
+            effectLimit?: number;
+            stages?: readonly import("../workflow-declaration.ts").WorkflowStage[];
+            handoffs?: readonly string[];
+            commands?: readonly string[];
+            commandWaits?: import("../workflow-declaration.ts").CommandWaits;
+        }[];
+        kind: "admitted";
+    };
+}>;
+type ReloadSettings = DaemonSettings & {
+    readonly reloadCommand: readonly string[];
+    readonly loadBundle: WorkflowBundleLoader;
+    readonly turnSettings: TurnSettingsSource;
+};
+type Generations = Pick<ReturnType<typeof workflowGenerations>, "replace">;
+export declare function workflowReload(settings: ReloadSettings & {
+    readonly generations: Generations;
+}): WorkflowReloadPort;
+export {};

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

@@ -0,0 +1,244 @@
+import { execFile } from "node:child_process";
+import { join } from "node:path";
+import { promisify } from "node:util";
+import { record } from "../protocol.js";
+import { serviceLimits } from "../service/service.js";
+import { isWorkflowDeclaration, } from "../workflow-declaration.js";
+import { workflowRefusals, } from "../workflow-refusals.js";
+import { ticketRegistrations, ticketRegistrationTable, } from "./ticket-registration.js";
+import { scheduledDeclarations } from "./workflow-schedules.js";
+import { keptDigests, profileRefusal, reloadedSettings, settingChanges, } from "./settings-reload.js";
+const executed = promisify(execFile);
+function refused(code, detail) {
+    return { kind: "refused", code, detail };
+}
+export function queueWorkflowId(settings) {
+    return settings.declarations?.find((declaration) => declaration.queue === true)?.workflowId;
+}
+export async function daemonRegistrations(settings) {
+    const conflict = settings.workflowRefusals?.find((refusal) => refusal.codes.includes("queue-workflow-conflict"));
+    if (conflict !== undefined)
+        return {
+            table: [],
+            admitted: {
+                kind: "rejected",
+                detail: `queue-workflow-conflict: ${conflict.scope} ${conflict.label}`,
+            },
+        };
+    const table = ticketRegistrationTable({
+        repository: settings.repository,
+        command: settings.ticketCommand,
+        nextCommand: settings.nextCommand,
+        githubCommand: settings.githubCommand,
+    }, settings.declarations);
+    const admitted = await ticketRegistrations(settings.manifests, {
+        table,
+        commands: settings.commands ?? {},
+        ...(settings.bundleDigest === undefined
+            ? {}
+            : { bundleDigest: settings.bundleDigest }),
+    });
+    return {
+        table,
+        admitted: admitted.kind === "rejected"
+            ? admitted
+            : {
+                ...admitted,
+                registrations: admitted.registrations.map((registration) => ({
+                    ...registration,
+                    ...(settings.queueMilliseconds !== undefined &&
+                        registration.workflowId === queueWorkflowId(settings)
+                        ? { admission: settings.queueLanes ?? 1, queue: true }
+                        : {}),
+                })),
+            },
+    };
+}
+function declaredWorkflows(value) {
+    if (!Array.isArray(value))
+        return undefined;
+    const declarations = [];
+    for (const entry of value) {
+        const { functionName, ...declaration } = record(entry) ?? {};
+        if (typeof functionName !== "string" || !isWorkflowDeclaration(declaration))
+            return undefined;
+        declarations.push({ ...declaration, functionName });
+    }
+    return declarations;
+}
+function manifestPaths(value) {
+    const fields = record(value);
+    if (fields === undefined)
+        return undefined;
+    const entries = Object.entries(fields);
+    const paths = entries.filter((entry) => typeof entry[1] === "string");
+    return paths.length === entries.length
+        ? Object.fromEntries(paths)
+        : undefined;
+}
+function parsedOutput(output) {
+    try {
+        return record(JSON.parse(output));
+    }
+    catch {
+        return undefined;
+    }
+}
+function outputRefusal(value) {
+    const error = value?.["error"];
+    if (typeof error === "string")
+        return refused("reload-failed", error);
+    const refusal = record(value?.["refusal"]);
+    const code = refusal?.["code"];
+    const detail = refusal?.["detail"];
+    return typeof code === "string" && typeof detail === "string"
+        ? refused(code, detail)
+        : undefined;
+}
+function preparedBundle(output) {
+    const value = parsedOutput(output);
+    const refusal = outputRefusal(value);
+    if (refusal !== undefined)
+        return refusal;
+    const bundleDigest = value?.["bundleDigest"];
+    const manifests = manifestPaths(value?.["manifests"]);
+    const declarations = declaredWorkflows(value?.["declarations"]);
+    const settings = reloadedSettings(value);
+    if (typeof bundleDigest !== "string" ||
+        manifests === undefined ||
+        declarations === undefined ||
+        settings === undefined)
+        return refused("reload-failed", "The reload command printed no workflow bundle.");
+    return {
+        kind: "prepared",
+        bundleDigest,
+        manifests,
+        declarations,
+        workflowRefusals: workflowRefusals(value?.["workflowRefusals"]),
+        ...settings,
+    };
+}
+async function prepared(command) {
+    const [executable = "", ...fixed] = command;
+    const output = await executed(executable, fixed, {
+        encoding: "utf8",
+        maxBuffer: 16 * 1024 * 1024,
+    }).then((result) => result.stdout, (error) => String(Reflect.get(Object(error), "stdout")));
+    return preparedBundle(output);
+}
+function restartFacts(declarations) {
+    const schedules = new Map(declarations
+        .filter((declaration) => declaration.schedule !== undefined)
+        .map((declaration) => [declaration.workflowId, declaration.schedule]));
+    return JSON.stringify({
+        queue: queueWorkflowId({ declarations }) ?? null,
+        schedules: [...schedules.keys()]
+            .sort()
+            .map((workflowId) => [workflowId, schedules.get(workflowId)]),
+    });
+}
+function refusalName(refusal) {
+    return `${refusal.scope} ${refusal.label}`;
+}
+function addedRefusals(current, next) {
+    const known = new Set(current.map(refusalName));
+    const added = next.filter((refusal) => !known.has(refusalName(refusal)));
+    if (added.length === 0)
+        return undefined;
+    const reasons = added.map((refusal) => `${refusalName(refusal)}: ${refusal.codes.join(", ")}`);
+    return refused("reload-failed", `The reload gives new workflow refusals: ${reasons.join("; ")}`);
+}
+async function reloaded(settings, bundle) {
+    const scheduled = scheduledDeclarations({ declarations: bundle.declarations, schedules: settings.schedules }, {
+        repository: settings.repository,
+        documentBytes: serviceLimits.documentBytes,
+    });
+    if (scheduled.kind === "refused")
+        return refused("reload-failed", `${scheduled.reason}: ${scheduled.detail}`);
+    if (restartFacts(scheduled.declarations) !==
+        restartFacts(settings.declarations ?? []))
+        return refused("reload-needs-restart", "The queue workflow or a schedule changed. Restart the service.");
+    let generation;
+    try {
+        generation = await settings.loadBundle(join(settings.directory, "workflow-bundles", bundle.bundleDigest));
+    }
+    catch (error) {
+        return refused("reload-failed", `The new bundle did not load: ${String(error)}`);
+    }
+    const { table, admitted } = await daemonRegistrations({
+        ...settings,
+        bundleDigest: bundle.bundleDigest,
+        manifests: bundle.manifests,
+        declarations: scheduled.declarations,
+        workflowRefusals: bundle.workflowRefusals,
+    });
+    if (admitted.kind === "rejected")
+        return refused("reload-failed", admitted.detail);
+    settings.generations.replace({
+        registrations: admitted.registrations,
+        table,
+        workflows: generation.workflows,
+        handler: generation.handler,
+    });
+    return {
+        kind: "reloaded",
+        bundleDigest: bundle.bundleDigest,
+        workflows: admitted.registrations,
+        workflowRefusals: bundle.workflowRefusals,
+    };
+}
+function reloadLine(outcome, digests) {
+    if (outcome.kind === "refused")
+        return `Workflow reload: refused ${outcome.code}: ${outcome.detail}\n`;
+    return `Workflow reload: ${outcome.kind} ${String(digests.previous)} -> ${String(digests.current)}\n`;
+}
+async function workflowPart(settings, prepared) {
+    const { state, bundle } = prepared;
+    const added = addedRefusals(state.workflowRefusals, bundle.workflowRefusals);
+    if (added !== undefined)
+        return added;
+    if (bundle.bundleDigest === state.bundleDigest)
+        return { kind: "unchanged", workflowRefusals: bundle.workflowRefusals };
+    return reloaded(settings, bundle);
+}
+async function reloadOutcome(settings, state) {
+    const kept = (outcome) => ({ outcome, state });
+    const bundle = await prepared(settings.reloadCommand);
+    if (bundle.kind === "refused")
+        return kept(bundle);
+    const profiles = profileRefusal(settings, bundle.turnSettings);
+    if (profiles !== undefined)
+        return kept(refused(profiles.code, profiles.detail));
+    const workflows = await workflowPart(settings, { state, bundle });
+    if (workflows.kind === "refused")
+        return kept(workflows);
+    const changes = settingChanges(state.settingDigests, bundle.settingDigests);
+    settings.turnSettings.replace(bundle.turnSettings);
+    return {
+        outcome: { ...workflows, ...changes },
+        state: {
+            bundleDigest: workflows.kind === "reloaded"
+                ? workflows.bundleDigest
+                : state.bundleDigest,
+            workflowRefusals: workflows.workflowRefusals,
+            settingDigests: keptDigests(state.settingDigests, {
+                digests: bundle.settingDigests,
+                reloadedFields: changes.reloadedFields,
+            }),
+        },
+    };
+}
+export function workflowReload(settings) {
+    let state = {
+        bundleDigest: settings.bundleDigest,
+        workflowRefusals: workflowRefusals(settings.workflowRefusals),
+        settingDigests: settings.settingDigests ?? {},
+    };
+    return async () => {
+        const previous = state.bundleDigest;
+        const step = await reloadOutcome(settings, state);
+        state = step.state;
+        process.stdout.write(reloadLine(step.outcome, { previous, current: state.bundleDigest }));
+        return step.outcome;
+    };
+}

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

@@ -4,8 +4,9 @@ interface ReplayRun {
     readonly runId: string;
     readonly workflowId?: string;
 }
+type ReplayState = Pick<AuthorityState, "details" | "runs">;
 interface ReplayPorts {
-    readonly state: () => Promise<Pick<AuthorityState, "details">>;
+    readonly state: () => Promise<ReplayState>;
     readonly run: (receipt: string) => Promise<ReplayRun | undefined>;
     readonly available: (runId: string, workflowId?: string) => Promise<boolean>;
     readonly submit: (command: Readonly<Record<string, unknown>>) => Promise<{

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

@@ -18,8 +18,8 @@ async function located(ports, receipt) {
     return undefined;
 }
 async function observedReplay(ports, replay) {
-    const { runId, receipt, available } = replay;
-    const observation = (await ports.state()).details[runId]?.observation;
+    const { state, runId, receipt, available } = replay;
+    const observation = state.details[runId]?.observation;
     const unavailable = observation?.reason === "pinned-workflow-unavailable";
     if (available !== unavailable)
         return true;
@@ -49,7 +49,11 @@ export function pinnedWorkflowHandler(handler, ports) {
         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 })))
+        const state = await ports.state();
+        if (state.runs[run.runId]?.status === "cancelled")
+            return Response.json({ ok: true });
+        const replay = { state, runId: run.runId, receipt, available };
+        if (!(await observedReplay(ports, replay)))
             return new Response("workflow-observation-unavailable", { status: 503 });
         if (available)
             return handler(request, run.runId);

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

@@ -1,10 +1,12 @@
 import type { WorkerPort } from "../service/worker-port.ts";
 import type { DeclaredWorkflow } from "../workflow-declaration.ts";
+import type { SchedulePort } from "../schedule-progress.ts";
 interface ScheduleSettings {
     readonly directory: string;
     readonly runtimeDirectory: string;
     readonly declarations?: readonly DeclaredWorkflow[];
     readonly scheduleClock?: () => number;
+    readonly scheduleObservationClock?: () => number;
     readonly submit: WorkerPort["submit"];
 }
 export declare function scheduledDeclarations(settings: {
@@ -23,5 +25,6 @@ export declare function scheduledDeclarations(settings: {
 };
 export declare function workflowSchedules(settings: ScheduleSettings): Promise<{
     readonly stop: () => Promise<void>;
+    readonly request: SchedulePort;
 }>;
 export {};