cloving 1.3.0 → 1.5.0

package/dist/src/service/queue-spend.js

@@ -0,0 +1,68 @@
+import { queueSpending } from "../queue-spend.js";
+import { priceOf } from "../worker-usage.js";
+import { reportFields } from "./worker-totals.js";
+export async function queueRun(context, runId) {
+    const { queries } = context.authority;
+    if ((await queries.manifest(runId))?.queue === true)
+        return true;
+    if ((await queries.workflowIds([runId]))[runId] !== "develop-issue")
+        return false;
+    const { events } = await queries.eventsAfter({ runId, after: 0, limit: 1 });
+    return (events[0]?.type === "run.created" &&
+        events[0].payload["resolver"] === "issue-command:1");
+}
+export async function queueSpend(context) {
+    const limitUsd = context.queueDailySpendLimitUsd;
+    if (limitUsd === undefined)
+        return {};
+    const now = Date.parse(context.clock());
+    const operations = await context.authority.effects.workerTurns({
+        after: new Date(now - 24 * 3_600_000).toISOString(),
+        through: new Date(now).toISOString(),
+    });
+    const runIds = [...new Set(operations.map((operation) => operation.runId))];
+    const costs = [];
+    const totals = {
+        costs,
+        unknownTurns: 0,
+        turnsInWork: 0,
+    };
+    const queued = new Set();
+    for (const runId of runIds) {
+        if (await queueRun(context, runId))
+            queued.add(runId);
+    }
+    for (const operation of operations) {
+        if (queued.has(operation.runId))
+            await countTurn(context, { operation, totals });
+    }
+    const spending = queueSpending(totals.costs, limitUsd);
+    const spentUsd = totals.costs.length === 0 && totals.unknownTurns > 0
+        ? null
+        : spending.spentUsd;
+    return {
+        spend: {
+            limitUsd,
+            spentUsd,
+            unknownTurns: totals.unknownTurns,
+            turnsInWork: totals.turnsInWork,
+            windowHours: 24,
+            holding: spentUsd !== null && spending.holding,
+        },
+    };
+}
+async function countTurn(context, turn) {
+    const { operation, totals } = turn;
+    if (operation.settledSequence === null) {
+        totals.turnsInWork += 1;
+        return;
+    }
+    const report = reportFields(operation.result === null
+        ? undefined
+        : await context.authority.queries.document(operation.result));
+    const cost = priceOf(report["costUsd"]) ?? priceOf(report["estimatedCostUsd"]);
+    if (cost === null)
+        totals.unknownTurns += 1;
+    else
+        totals.costs.push(cost);
+}

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

@@ -2,6 +2,7 @@ import type { CommandWaits, WorkflowStage, WorkflowStages } from "../workflow-de
 import type { SubmissionContract } from "../submission.ts";
 import type { ExecutionManifest } from "../workflow-admission.ts";
 import type { AvailableManifest } from "../broker/actor/delivery-intents.ts";
+import { type WorkflowRefusal } from "../workflow-refusals.ts";
 export interface WorkflowBundleStore {
     readonly directory: string;
     readonly repository: string;
@@ -52,8 +53,33 @@ export interface Registry {
     readonly bundle: (pinned: ExecutionManifest) => Promise<string | undefined>;
     readonly available: AvailableManifest;
 }
-export declare function workflowRegistry(workflows: readonly WorkflowRegistration[], options?: {
+export interface RegistryOptions {
     readonly retainedWorkflows?: readonly WorkflowRegistration[];
     readonly workflowBundles?: WorkflowBundleStore;
     readonly retainedWorkflow?: AvailableManifest;
-}): Registry;
+}
+export interface ReplaceableRegistry extends Registry {
+    readonly replace: (workflows: readonly WorkflowRegistration[]) => void;
+}
+export declare function replaceableRegistry(workflows: readonly WorkflowRegistration[], options?: RegistryOptions): ReplaceableRegistry;
+export declare function workflowRegistry(workflows: readonly WorkflowRegistration[], options?: RegistryOptions): Registry;
+interface WorkflowInventory {
+    readonly bundleDigest?: string;
+    readonly workflowRefusals: readonly WorkflowRefusal[];
+}
+export interface WorkflowCatalog {
+    readonly registry: Registry;
+    readonly inventory: () => WorkflowInventory;
+    readonly replace: (next: {
+        readonly bundleDigest: string;
+        readonly workflows: readonly WorkflowRegistration[];
+        readonly workflowRefusals: readonly WorkflowRefusal[];
+    }) => void;
+    readonly replaceRefusals: (refusals: readonly WorkflowRefusal[]) => void;
+}
+export declare function workflowCatalog(options: RegistryOptions & {
+    readonly workflows: readonly WorkflowRegistration[];
+    readonly bundleDigest?: string;
+    readonly workflowRefusals?: readonly WorkflowRefusal[];
+}): WorkflowCatalog;
+export {};

package/dist/src/service/registry.js

@@ -1,6 +1,7 @@
 import { workflowPin } from "../broker/workflow-pin.js";
 import { declaredManifest } from "../execution-pin.js";
 import { readRetainedWorkflowBundle } from "../../tools/workflow-bundles.js";
+import { workflowRefusals, } from "../workflow-refusals.js";
 function registered(workflow) {
     const manifest = declaredManifest(workflow.manifest, workflow);
     return {
@@ -19,6 +20,30 @@ function availableVersions(workflow) {
     delete manifest.bundleDigest;
     return [workflow, { ...workflow, manifest, pin: workflowPin(manifest) }];
 }
+export function replaceableRegistry(workflows, options = {}) {
+    let earlier = [...workflows, ...(options.retainedWorkflows ?? [])];
+    let current = workflowRegistry(workflows, options);
+    return {
+        get workflowIds() {
+            return current.workflowIds;
+        },
+        get workflowStages() {
+            return current.workflowStages;
+        },
+        byId: (workflowId) => current.byId(workflowId),
+        byPin: (pin) => current.byPin(pin),
+        bundle: (pinned) => current.bundle(pinned),
+        available: (pinned) => current.available(pinned),
+        replace: (next) => {
+            const replacement = workflowRegistry(next, {
+                ...options,
+                retainedWorkflows: earlier,
+            });
+            earlier = [...next, ...earlier];
+            current = replacement;
+        },
+    };
+}
 export function workflowRegistry(workflows, options = {}) {
     const current = workflows.map(registered);
     const available = [
@@ -54,3 +79,26 @@ export function workflowRegistry(workflows, options = {}) {
         },
     };
 }
+export function workflowCatalog(options) {
+    const registry = replaceableRegistry(options.workflows, options);
+    let inventory = {
+        ...(options.bundleDigest === undefined
+            ? {}
+            : { bundleDigest: options.bundleDigest }),
+        workflowRefusals: workflowRefusals(options.workflowRefusals),
+    };
+    return {
+        registry,
+        inventory: () => inventory,
+        replace: (next) => {
+            registry.replace(next.workflows);
+            inventory = {
+                bundleDigest: next.bundleDigest,
+                workflowRefusals: next.workflowRefusals,
+            };
+        },
+        replaceRefusals: (refusals) => {
+            inventory = { ...inventory, workflowRefusals: refusals };
+        },
+    };
+}

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

@@ -1,16 +1,26 @@
+import type { SchedulePort } from "../schedule-progress.ts";
+import type { QueuePort } from "../queue-state.ts";
 import type { Authority, CommandRecord, StoreReceipt } from "../broker/actor/authority.ts";
 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 { Registry, WorkflowCatalog } from "./registry.ts";
 import type { CommandEffects } from "../command-settings.ts";
-export interface ServiceContext {
+import type { RunTurns, TurnDetails } from "../record-retention.ts";
+export interface ServiceReads {
     readonly workerHarness?: (operationId: string) => Promise<string | undefined>;
+    readonly turnDetails?: (turns: RunTurns) => Promise<TurnDetails | undefined>;
+}
+export interface ServiceContext extends ServiceReads {
+    readonly version?: string;
+    readonly schedule?: SchedulePort;
+    readonly queue?: QueuePort;
+    readonly queueDailySpendLimitUsd?: number;
     readonly commandEffects?: CommandEffects;
     readonly authority: Authority;
     readonly registry: Registry;
-    readonly workflowRefusals?: readonly WorkflowRefusal[];
+    readonly workflowCatalog?: WorkflowCatalog;
+    readonly reload?: () => Promise<Reply>;
     readonly gateway: Gateway;
     readonly clock: () => string;
     readonly livenessMilliseconds: number;
@@ -21,11 +31,13 @@ export interface ServiceContext {
     readonly worldReports?: () => readonly unknown[];
     readonly changed?: ChangeSignal["next"];
 }
-export declare function queryMetadata(options: {
-    readonly workerHarness?: ServiceContext["workerHarness"];
+export declare function queryMetadata(options: ServiceReads & {
+    readonly version?: string;
+    readonly schedule?: SchedulePort;
+    readonly queue?: QueuePort;
+    readonly queueDailySpendLimitUsd?: number;
     readonly commandEffects?: CommandEffects;
-    readonly workflowRefusals?: readonly WorkflowRefusal[];
-}): Pick<ServiceContext, "workerHarness" | "commandEffects" | "workflowRefusals">;
+}): Pick<ServiceContext, "schedule" | "queue" | "workerHarness" | "turnDetails" | "commandEffects" | "queueDailySpendLimitUsd" | "version">;
 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;
@@ -34,3 +46,5 @@ export declare function committed(receipt: StoreReceipt): boolean;
 export declare function isIdentifier(value: unknown): value is string;
 export declare function wholeNumber(value: unknown, minimum: number): value is number;
 export declare function publicReceipt(record: CommandRecord): Fields;
+export declare function scheduleRequest(context: ServiceContext, parameters: Fields): Promise<Reply>;
+export declare function errorMessage(error: unknown): string;

package/dist/src/service/replies.js

@@ -1,14 +1,21 @@
 import { isRecordKey } from "../authority/commands.js";
-import { workflowRefusals, } from "../workflow-refusals.js";
 export function queryMetadata(options) {
     return {
+        ...(options.version === undefined ? {} : { version: options.version }),
+        ...(options.schedule === undefined ? {} : { schedule: options.schedule }),
+        ...(options.queue === undefined ? {} : { queue: options.queue }),
+        ...(options.queueDailySpendLimitUsd === undefined
+            ? {}
+            : { queueDailySpendLimitUsd: options.queueDailySpendLimitUsd }),
         ...(options.workerHarness === undefined
             ? {}
             : { workerHarness: options.workerHarness }),
+        ...(options.turnDetails === undefined
+            ? {}
+            : { turnDetails: options.turnDetails }),
         ...(options.commandEffects === undefined
             ? {}
             : { commandEffects: options.commandEffects }),
-        workflowRefusals: workflowRefusals(options.workflowRefusals),
     };
 }
 const codes = {
@@ -66,3 +73,10 @@ export function publicReceipt(record) {
         commandDigest: record.commandDigest,
     };
 }
+export function scheduleRequest(context, parameters) {
+    return (context.schedule?.(parameters) ??
+        Promise.resolve(failed("schedules-unavailable", {})));
+}
+export function errorMessage(error) {
+    return String(Reflect.get(Object(error), "message"));
+}

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

@@ -1,18 +1,22 @@
-import { metadataOf, outcomeOf } from "./run-metadata.js";
+import { commandWaitDisplay } from "./command-waits.js";
+import { scheduleMetadata, scheduledMetadata, metadataOf, outcomeOf, ticketMetadataPage, workflowMetadata, } from "./run-metadata.js";
 import { linksOf } from "../authority/handoff-chain.js";
+import { terminal } from "../authority/transitions.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 { turnDetailsOf, usageTotals } from "./worker-totals.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";
+import { workflowFields } from "./workflow-reload.js";
 async function snapshot(context) {
     const { authority } = context;
     const state = await authority.state();
     const sequences = await authority.queries.sequences();
     return {
+        now: context.clock(),
         links: await authority.queries.runLinks(),
         state,
         operations: await authority.operations(),
@@ -64,9 +68,16 @@ async function viewOf(context, scope) {
     if (run === undefined)
         return undefined;
     const details = state.details[run.runId];
+    const workflowId = scope.snapshot.workflowIds[run.runId] ?? run.workflow;
     const effects = await effectInput(context, run.runId);
     const input = {
         ...effects,
+        commandWaits: await commandWaitDisplay({
+            authority: context.authority,
+            runId: run.runId,
+            waits: state.commandWaits,
+            now: scope.snapshot.now,
+        }),
         closure: run.status === "cancelled"
             ? await context.authority.effects.closure(run.runId)
             : null,
@@ -84,10 +95,14 @@ async function viewOf(context, scope) {
     };
     return {
         ...runView(input),
+        ...(await scheduledMetadata(context, {
+            runId: run.runId,
+            workflowId,
+        })),
         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,
+        workflowId,
         latestAt: times[run.runId] ?? null,
         unresolvedEffects: unresolvedEffects(input),
         feedback: await feedbackOf(context, { state, runId: run.runId }),
@@ -96,6 +111,7 @@ async function viewOf(context, scope) {
 function summary(view) {
     return {
         runId: view.runId,
+        ...(view.scheduled === undefined ? {} : { scheduled: view.scheduled }),
         ...linksOf(view),
         input: view.input,
         workflowId: view.workflowId,
@@ -106,6 +122,7 @@ function summary(view) {
         latestSequence: view.latestSequence,
         latestAt: view.latestAt,
         pendingDecisions: view.pendingDecisions,
+        commandWaits: view.commandWaits,
     };
 }
 function full(view) {
@@ -135,7 +152,9 @@ async function submittedInput(context, digest) {
     return record(request?.["submission"]) ?? null;
 }
 async function listed(context, page) {
-    const identifiers = Object.keys(page.snapshot.state.runs)
+    const identifiers = Object.entries(page.snapshot.state.runs)
+        .filter(([, run]) => !page.active || !terminal.includes(run.status))
+        .map(([runId]) => runId)
         .sort()
         .filter((runId) => runId > page.after);
     const shown = identifiers.slice(0, page.limit);
@@ -144,14 +163,12 @@ 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
+        ...(context.version === undefined
             ? {}
-            : {
-                workflowStages: context.registry.workflowStages,
-            }),
+            : { serviceVersion: context.version }),
+        ...(await queueOverview(context)),
+        ...(await scheduleMetadata(context)),
+        ...workflowFields(context),
         runs,
         next: identifiers.length > shown.length ? (shown.at(-1) ?? null) : null,
         worldReports: context.worldReports?.() ?? [],
@@ -160,17 +177,24 @@ async function listed(context, page) {
 function listParameters(parameters) {
     const after = parameters["after"] ?? "";
     const limit = parameters["limit"] ?? 50;
+    const active = parameters["active"] ?? false;
     if (typeof after !== "string" || !wholeNumber(limit, 1) || limit > 500)
         return undefined;
-    return { after, limit };
+    if (typeof active !== "boolean")
+        return undefined;
+    return { after, limit, active };
 }
 export async function status(context, parameters) {
+    if (parameters["metadata"] === "workflows")
+        return workflowMetadata(context, parameters["runIds"]);
     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.");
+    if (parameters["metadata"] === "tickets")
+        return ticketMetadataPage(context, page);
     const current = await snapshot(context);
     if (runId === undefined)
         return listed(context, { snapshot: current, ...page });
@@ -182,6 +206,7 @@ export async function status(context, parameters) {
     return result("run-status", {
         run: {
             ...full({ ...view, ...totals }),
+            ...(await turnDetailsOf(context, { runId: view.runId, totals })),
             ...(await commandFields(context, view.commandOperations)),
             outcome: await outcomeOf(context, view),
             decisions: await decidedOf(context, {

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

@@ -1,8 +1,22 @@
 import { type Fields } from "../protocol.ts";
 import type { RunView } from "../authority/status.ts";
-import type { ServiceContext } from "./replies.ts";
+import { type ServiceContext } from "./replies.ts";
+export declare function workflowMetadata(context: ServiceContext, runIds: unknown): Promise<import("../protocol.ts").Reply>;
+export declare function ticketMetadataPage(context: ServiceContext, page: {
+    readonly after: string;
+    readonly limit: number;
+}): Promise<import("../protocol.ts").Reply>;
 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>;
+export declare function scheduleMetadata(context: ServiceContext): Promise<Fields>;
+export declare function scheduledMetadata(context: ServiceContext, run: {
+    readonly runId: string;
+    readonly workflowId: string;
+}): Promise<{
+    readonly scheduled?: {
+        readonly slot: number;
+    };
+}>;

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

@@ -1,5 +1,43 @@
 import { issueIdentity } from "../issue-identity.js";
 import { record } from "../protocol.js";
+import { invalidRequest, isIdentifier, result, } from "./replies.js";
+export async function workflowMetadata(context, runIds) {
+    if (!Array.isArray(runIds) ||
+        runIds.length === 0 ||
+        runIds.length > 500 ||
+        !runIds.every(isIdentifier) ||
+        new Set(runIds).size !== runIds.length)
+        return invalidRequest("Workflow metadata needs one to 500 distinct run IDs.");
+    const identities = await context.authority.queries.workflowIds(runIds);
+    return result("run-workflow-metadata", {
+        runs: runIds.map((runId) => ({
+            runId,
+            workflowId: identities[runId] ?? null,
+        })),
+    });
+}
+export async function ticketMetadataPage(context, page) {
+    const state = await context.authority.state();
+    const identifiers = Object.keys(state.runs)
+        .sort()
+        .filter((runId) => runId > page.after);
+    const shown = identifiers.slice(0, page.limit);
+    const runs = [];
+    for (const runId of shown) {
+        const digest = state.details[runId]?.input;
+        const document = digest
+            ? await context.authority.queries.document(digest)
+            : "{}";
+        const input = record(JSON.parse(document ?? "null"));
+        if (input === undefined)
+            throw new Error("report-ticket-metadata-unavailable");
+        runs.push({ runId, ticketId: ticketIdOf(input) });
+    }
+    return result("run-ticket-metadata", {
+        runs,
+        next: identifiers.length > shown.length ? shown.at(-1) : null,
+    });
+}
 export async function outcomeOf(context, view) {
     if (view.state !== "completed")
         return null;
@@ -20,13 +58,22 @@ export async function outcomeOf(context, view) {
         ...(issueUpdate === "failed" ? { issueUpdate } : {}),
     };
 }
+function ticketOf(input) {
+    const declared = record(record(input?.["input"])?.["ticket"]);
+    const id = declared === undefined ? input?.["ticketId"] : declared["id"];
+    const text = declared === undefined ? input?.["ticket"] : declared["text"];
+    return {
+        id: typeof id === "string" ? id : undefined,
+        text: typeof text === "string" ? text : undefined,
+    };
+}
 function titleOf(input, workflowId) {
-    const ticket = input?.["ticket"];
-    if (typeof ticket !== "string")
+    const ticket = ticketOf(input).text;
+    if (ticket === undefined)
         return null;
     const fallback = `Cloving task ${String(input?.["cycleId"])}`;
     const lines = ticket.split("\n");
-    if (workflowId === "develop-prompt") {
+    if (workflowId === "develop-prompt" && !Object.hasOwn(input ?? {}, "input")) {
         const first = lines.find((line) => /\S/.test(line));
         return first === undefined
             ? fallback
@@ -42,12 +89,50 @@ export async function metadataOf(context, source) {
         ? 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,
+        ticketId: ticketIdOf(input),
         title: titleOf(input, source.workflowId),
-        ...(source.workflowId === "develop-issue"
-            ? { issueIdentity: issueIdentity(input?.["ticket"]) }
-            : {}),
+        ...(ticketOf(input).text === undefined
+            ? {}
+            : { issueIdentity: issueIdentity(ticketOf(input).text) }),
+    };
+}
+function ticketIdOf(input) {
+    const ticketId = ticketOf(input).id;
+    return ticketId === undefined || ticketId === "" ? null : ticketId;
+}
+export async function scheduleMetadata(context) {
+    if (context.schedule === undefined)
+        return {};
+    const reply = await context.schedule({ action: "list" });
+    if (reply.kind !== "result" || !Array.isArray(reply.result["schedules"]))
+        return { schedules: { status: "unavailable" } };
+    const schedules = reply.result["schedules"];
+    if (schedules.length === 0)
+        return {};
+    return {
+        schedules: schedules.map((value) => {
+            const schedule = record(value) ?? {};
+            return Object.fromEntries([
+                "workflowId",
+                "everySeconds",
+                "state",
+                "failuresInRow",
+                "nextAt",
+                "stoppedAt",
+            ].map((name) => [name, schedule[name]]));
+        }),
     };
 }
+export async function scheduledMetadata(context, run) {
+    const commandId = (await context.authority.queries.run(run.runId))
+        ?.admissionCommandId;
+    const prefix = `schedule:${run.workflowId}:`;
+    if (typeof commandId !== "string" || !commandId.startsWith(prefix))
+        return {};
+    const suffix = commandId.slice(prefix.length);
+    const slot = Number(suffix);
+    return /^(0|[1-9][0-9]*)$/.test(suffix) && Number.isSafeInteger(slot)
+        ? { scheduled: { slot } }
+        : {};
+}

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

@@ -1,10 +1,12 @@
 import { type Authority, type AuthorityTiming, type Delivery, type EffectSettings, type Refusal } from "../broker/actor/authority.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 WorkflowReloadPort } from "./workflow-reload.ts";
+import { type ServiceContext, type ServiceReads } from "./replies.ts";
 import { type WorkerPort } from "./worker-port.ts";
 import type { RunWaitTarget } from "../run-wait.ts";
 import type { CommandEffects } from "../command-settings.ts";
+import { type CommandWaitPort } from "./command-waits.ts";
 export type { WorkflowRegistration } from "./registry.ts";
 export type { EffectReply, EffectReport, EffectRequest, WorkerPort, } from "./worker-port.ts";
 export interface ServiceTiming {
@@ -27,6 +29,7 @@ export interface ServiceHost {
     readonly reports?: () => readonly unknown[];
 }
 export interface HostPorts {
+    readonly commandWait: CommandWaitPort;
     readonly runWait?: {
         readonly target: (runId: string) => Promise<RunWaitTarget | undefined>;
         readonly observe: WorkerPort["observe"];
@@ -47,8 +50,11 @@ export interface HostPorts {
     readonly openGate: WorkerPort["openGate"];
     readonly registerWait: WorkerPort["registerWait"];
 }
-export interface ServiceOptions {
-    readonly workerHarness?: ServiceContext["workerHarness"];
+export interface ServiceOptions extends ServiceReads {
+    readonly version?: string;
+    readonly schedule?: NonNullable<ServiceContext["schedule"]>;
+    readonly queue?: NonNullable<ServiceContext["queue"]>;
+    readonly queueDailySpendLimitUsd?: number;
     readonly commandEffects?: CommandEffects;
     readonly stateDirectory: string;
     readonly runtimeDirectory: string;
@@ -57,6 +63,8 @@ export interface ServiceOptions {
     readonly workflowBundles?: WorkflowBundleStore;
     readonly retainedWorkflow?: Registry["available"];
     readonly workflowRefusals?: readonly WorkflowRefusal[];
+    readonly bundleDigest?: string;
+    readonly reload?: WorkflowReloadPort;
     readonly delivery: Delivery;
     readonly host?: (ports: HostPorts) => Promise<ServiceHost>;
     readonly timing?: ServiceTiming;