cloving 1.1.0 → 1.2.0

package/dist/src/daemon/ticket-registration.js

@@ -1,9 +1,14 @@
 import { createHash } from "node:crypto";
 import { admitCompiled } from "../cli/validate.js";
 import { ticketCommandText, ticketText } from "./ticket-source.js";
-export const ticketWorkflow = "develop-ticket";
-export const promptWorkflow = "develop-prompt";
-export const issueWorkflow = "develop-issue";
+import { bundledWorkflowIds } from "../workflow-discovery.js";
+import { declaredManifest } from "../execution-pin.js";
+import { record } from "../protocol.js";
+import { issueIdentity } from "../issue-identity.js";
+import { ticketDependencyWaits, TicketDependencyReadError, } from "./ticket-dependency-waits.js";
+export const ticketWorkflow = bundledWorkflowIds.ticket;
+export const promptWorkflow = bundledWorkflowIds.prompt;
+export const issueWorkflow = bundledWorkflowIds.issue;
 export const ticketCapabilities = ["claude", "github"];
 const ticketIdentifier = /^[A-Za-z0-9._:-]{1,64}$/;
 function rejected(code, detail) {
@@ -38,7 +43,15 @@ async function ticket(source, request) {
 async function nextTicket(source, request) {
     if (source.nextCommand === undefined)
         return rejected("next-source-not-configured", "The daemon has no next-ticket command. Set CLOVING_NEXT_COMMAND.");
-    const selected = await ticketCommandText(source.nextCommand, request.signal);
+    const selected = await ticketCommandText(source.nextCommand, {
+        signal: request.signal,
+        skipTickets: [
+            ...new Set([
+                ...(request.activeTickets ?? []).flatMap((input) => typeof input["ticketId"] === "string" ? [input["ticketId"]] : []),
+                ...(source.skipTickets ?? []),
+            ]),
+        ].sort(),
+    });
     if (selected.kind === "failed")
         return rejected("next-ticket-not-available", selected.detail);
     if (selected.text === "")
@@ -55,18 +68,43 @@ export function ticketResolver(source) {
     };
 }
 export function issueResolver(source) {
+    const waits = ticketDependencyWaits(source);
     return {
         id: "issue-command",
         version: "1",
-        resolve: async (request) => {
-            const resolution = await ticket(source, request);
-            if (resolution.kind === "rejected")
-                return resolution;
-            return {
-                kind: "resolved",
-                input: { ...Object(resolution.input), delivery: "pull-request" },
-            };
-        },
+        skippedTickets: waits.skipped,
+        resolve: (request) => issueTicket({ source, waits }, request).catch((error) => {
+            if (!(error instanceof TicketDependencyReadError))
+                throw error;
+            return rejected("ticket-not-available", "The ticket dependencies could not be read. Retry this command.");
+        }),
+    };
+}
+async function issueTicket(context, request) {
+    const { source, waits } = context;
+    const skipTickets = request.submission["ticket"] === "next"
+        ? await waits.refresh(request.signal)
+        : [];
+    const resolution = await ticket({ ...source, skipTickets }, request);
+    if (resolution.kind === "rejected")
+        return resolution;
+    const input = record(resolution.input) ?? {};
+    const identity = issueIdentity(input["ticket"]);
+    if ((request.activeTickets ?? []).some((active) => active["ticketId"] === input["ticketId"] ||
+        (identity !== null &&
+            JSON.stringify(issueIdentity(active["ticket"])) ===
+                JSON.stringify(identity))))
+        return rejected("ticket-active", "An active run already works on this ticket.");
+    const dependencies = await waits.check({
+        ticketId: String(input["ticketId"]),
+        ticket: String(input["ticket"]),
+        signal: request.signal,
+    });
+    if (dependencies.length > 0)
+        return rejected("ticket-dependency-open", `Ticket ${String(input["ticketId"])} needs open issues: ${dependencies.map((id) => `#${id}`).join(", ")}.`);
+    return {
+        kind: "resolved",
+        input: { ...input, delivery: "pull-request" },
     };
 }
 export function promptResolver(repository) {
@@ -89,6 +127,7 @@ export function ticketRegistrationTable(source, declarations = []) {
             workflowId: ticketWorkflow,
             functionName: "developTicket",
             effectLimit: 8,
+            handoffs: [],
             submission: { maximumBytes: 4_096, fields: { ticket: "string" } },
             resolver: ticketResolver(source),
         },
@@ -96,13 +135,15 @@ export function ticketRegistrationTable(source, declarations = []) {
             workflowId: issueWorkflow,
             functionName: "developTicket",
             effectLimit: 20,
+            handoffs: [],
             submission: { maximumBytes: 4_096, fields: { ticket: "string" } },
             resolver: issueResolver(source),
         },
         {
-            workflowId: "develop-prd",
+            workflowId: bundledWorkflowIds.prd,
             functionName: "developPrd",
             effectLimit: 8,
+            handoffs: [issueWorkflow],
             submission: { maximumBytes: 65_536, fields: { prompt: "string" } },
             resolver: promptResolver(source.repository),
         },
@@ -110,6 +151,7 @@ export function ticketRegistrationTable(source, declarations = []) {
             workflowId: promptWorkflow,
             functionName: "developTicket",
             effectLimit: 8,
+            handoffs: [],
             submission: { maximumBytes: 65_536, fields: { prompt: "string" } },
             resolver: promptResolver(source.repository),
         },
@@ -119,6 +161,12 @@ export function ticketRegistrationTable(source, declarations = []) {
             effectLimit: declaration.effectLimit,
             capabilities: declaration.capabilities,
             submission: declaration.input,
+            ...(declaration.stages === undefined
+                ? {}
+                : { stages: declaration.stages }),
+            ...(declaration.handoffs === undefined
+                ? {}
+                : { handoffs: declaration.handoffs }),
             resolver: declaredResolver(source.repository),
         })),
     ];
@@ -147,17 +195,26 @@ export async function ticketRegistrations(manifests, options) {
             };
         ids.add(row.workflowId);
     }
+    for (const row of options.table) {
+        const unknown = row.handoffs?.find((target) => !ids.has(target));
+        if (unknown !== undefined)
+            return {
+                kind: "rejected",
+                detail: `unknown-handoff-target: ${row.workflowId} -> ${unknown}`,
+            };
+    }
     const registrations = [];
     for (const row of options.table) {
-        const manifest = manifests[row.functionName];
+        const { functionName, capabilities = ticketCapabilities, ...registration } = row;
+        const manifest = manifests[functionName];
         if (manifest === undefined)
             return {
                 kind: "rejected",
-                detail: `Missing manifest for workflow function ${row.functionName}.`,
+                detail: `Missing manifest for workflow function ${functionName}.`,
             };
         const admission = await admitCompiled(manifest, {
             file: manifest,
-            capabilities: row.capabilities ?? ticketCapabilities,
+            capabilities,
         });
         if (admission.kind === "rejected")
             return {
@@ -165,12 +222,9 @@ export async function ticketRegistrations(manifests, options) {
                 detail: `${admission.error.code}: ${admission.error.detail}`,
             };
         registrations.push({
-            workflowId: row.workflowId,
-            manifest: admission.manifest,
+            ...registration,
+            manifest: declaredManifest(admission.manifest, row),
             availability: "available",
-            effectLimit: row.effectLimit,
-            submission: row.submission,
-            resolver: row.resolver,
         });
     }
     return { kind: "admitted", registrations };

package/dist/src/daemon/ticket-source.d.ts

@@ -14,4 +14,7 @@ export interface TicketRequest {
     readonly signal: AbortSignal;
 }
 export declare function ticketText(command: readonly string[], request: TicketRequest): Promise<TicketRead>;
-export declare function ticketCommandText(command: readonly string[], signal: AbortSignal): Promise<TicketRead>;
+export declare function ticketCommandText(command: readonly string[], request: AbortSignal | {
+    readonly signal: AbortSignal;
+    readonly skipTickets: readonly string[];
+}): Promise<TicketRead>;

package/dist/src/daemon/ticket-source.js

@@ -26,10 +26,16 @@ export function ticketText(command, request) {
     const [executable = "", ...fixed] = command;
     return ticketCommandText([executable, ...fixed, request.ticketId], request.signal).then((result) => result.kind === "failed" ? result : printed(result.text));
 }
-export function ticketCommandText(command, signal) {
+export function ticketCommandText(command, request) {
     const [executable = "", ...fixed] = command;
     return executed(executable, fixed, {
-        signal,
+        signal: request instanceof AbortSignal ? request : request.signal,
+        env: request instanceof AbortSignal
+            ? process.env
+            : {
+                ...process.env,
+                CLOVING_SKIP_TICKETS: request.skipTickets.join(" "),
+            },
         maxBuffer: 4 * ticketLimits.textBytes,
         encoding: "utf8",
     }).then((output) => ({ kind: "read", text: output.stdout.trim() }), ended);

package/dist/src/decision-visibility.d.ts

@@ -0,0 +1,2 @@
+import type { Fields } from "./protocol.ts";
+export declare function operationalDecision(decision: Fields, workflowId: string): Fields;

package/dist/src/decision-visibility.js

@@ -0,0 +1,10 @@
+export function operationalDecision(decision, workflowId) {
+    if (workflowId !== "analyze-chats")
+        return decision;
+    return {
+        ...decision,
+        prompt: "Private analysis question. Run cloving questions to view it.",
+        context: [],
+        feedback: [],
+    };
+}

package/dist/src/execution-pin.d.ts

@@ -1,4 +1,8 @@
 import type { AdmissionResult, ExecutionManifest } from "./workflow-admission.ts";
+export declare function executionCapabilities(manifest: ExecutionManifest): string;
 export declare function pinnedIdentity(manifest: ExecutionManifest): string;
 export declare function resumePinned(pinned: ExecutionManifest, available: ExecutionManifest): AdmissionResult;
 export declare function readExecutionManifest(value: unknown): ExecutionManifest;
+export declare function declaredManifest(manifest: ExecutionManifest, declaration: {
+    readonly handoffs?: readonly string[];
+}): ExecutionManifest;

package/dist/src/execution-pin.js

@@ -1,8 +1,10 @@
+import { isWorkflowHandoffs } from "./workflow-declaration.js";
 const canonical = {
     name: (manifest) => JSON.stringify(manifest.name),
     workflowId: (manifest) => JSON.stringify(manifest.workflowId),
     steps: (manifest) => JSON.stringify([...manifest.steps].sort()),
     capabilities: (manifest) => JSON.stringify([...manifest.capabilities].sort()),
+    handoffs: (manifest) => JSON.stringify([...(manifest.handoffs ?? [])].sort()),
     artifacts: (manifest) => JSON.stringify(Object.keys(manifest.artifacts)
         .sort()
         .map((name) => [name, manifest.artifacts[name]])),
@@ -20,11 +22,18 @@ const fields = [
     "resources",
     "toolchain",
 ];
+export function executionCapabilities(manifest) {
+    const handoff = manifest.handoffs?.length ? ["handoff"] : [];
+    return JSON.stringify([...new Set([...manifest.capabilities, ...handoff])].sort());
+}
 export function pinnedIdentity(manifest) {
-    return JSON.stringify(fields.map((field) => canonical[field](manifest)));
+    const identity = fields.map((field) => canonical[field](manifest));
+    if (manifest.handoffs?.length)
+        identity.push(canonical.handoffs(manifest));
+    return JSON.stringify(identity);
 }
 export function resumePinned(pinned, available) {
-    const changed = fields.find((field) => canonical[field](pinned) !== canonical[field](available));
+    const changed = [...fields, "handoffs"].find((field) => canonical[field](pinned) !== canonical[field](available));
     if (changed !== undefined)
         return {
             kind: "rejected",
@@ -36,11 +45,15 @@ export function resumePinned(pinned, available) {
 export function readExecutionManifest(value) {
     const fields = record(value);
     const toolchain = record(fields["toolchain"]);
+    const handoffs = fields["handoffs"];
+    if (Object.hasOwn(fields, "handoffs") && !isWorkflowHandoffs(handoffs))
+        throw new Error("invalid-handoffs");
     return {
         name: text(fields["name"]),
         workflowId: text(fields["workflowId"]),
         steps: texts(fields["steps"]),
         capabilities: texts(fields["capabilities"]),
+        ...(isWorkflowHandoffs(handoffs) ? { handoffs: [...handoffs] } : {}),
         artifacts: textRecord(fields["artifacts"]),
         resources: textRecord(fields["resources"]),
         toolchain: {
@@ -52,6 +65,14 @@ export function readExecutionManifest(value) {
         },
     };
 }
+export function declaredManifest(manifest, declaration) {
+    return readExecutionManifest({
+        ...manifest,
+        ...(declaration.handoffs === undefined
+            ? {}
+            : { handoffs: declaration.handoffs }),
+    });
+}
 function record(value) {
     if (!value || typeof value !== "object" || Array.isArray(value))
         return {};

package/dist/src/host/start-delivery.d.ts

@@ -9,6 +9,7 @@ export interface RunIntent extends Partial<Continuation> {
     readonly kind: string;
     readonly runId: string;
     readonly operationId: string;
+    readonly workflow: string;
 }
 export type RunOutcome = {
     readonly kind: "accepted";
@@ -27,7 +28,7 @@ export interface StartParts {
     readonly runs: () => Promise<readonly OperationRun[]>;
     readonly input: (runId: string) => Promise<string | undefined>;
     readonly document: (digest: string) => Promise<string | undefined>;
-    readonly workflow: (runId: string) => Promise<WorkflowFunction | undefined>;
+    readonly workflow: (intent: RunIntent) => Promise<WorkflowFunction | undefined>;
     readonly cancel: (receipt: string) => Promise<string>;
 }
 export interface StartDelivery {

package/dist/src/host/start-delivery.js

@@ -31,7 +31,7 @@ async function continuation(parts, intent) {
 }
 async function delivered(parts, intent) {
     const continued = await continuation(parts, intent);
-    const workflow = await parts.workflow(intent.runId);
+    const workflow = await parts.workflow(intent);
     const input = await parts.input(intent.runId);
     if (workflow === undefined || input === undefined)
         throw new Error(`start-not-available: ${intent.runId}`);

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

@@ -42,6 +42,7 @@ export interface GateOpening {
     readonly kind: "question" | "approval";
     readonly prompt: string;
     readonly subject: string;
+    readonly expiresAt?: string;
 }
 export interface WaitRegistration {
     readonly runId: string;

package/dist/src/host/step-bridge-host.js

@@ -168,6 +168,9 @@ async function opening(hold, subject) {
         kind,
         prompt,
         subject: `sha256:${createHash("sha256").update(prompt).digest("hex")}`,
+        ...(request.expiresAt === undefined
+            ? {}
+            : { expiresAt: request.expiresAt }),
     });
 }
 async function gate(hold, request) {
@@ -194,6 +197,19 @@ export function stepBridge(ports) {
     return {
         effect: (request) => effect(hold, request),
         gate: (request) => gate(hold, request),
+        handoff: (request) => effect(hold, {
+            scope: {
+                phase: "handoff",
+                operation: "handoff",
+                round: 1,
+                key: createHash("sha256").update(ports.call().stepId).digest("hex"),
+            },
+            capability: "handoff",
+            method: "run",
+            target: request.workflowId,
+            payload: JSON.stringify(request.input),
+            units: 1,
+        }),
     };
 }
 export function registerStepBridge(bridge) {

package/dist/src/host/world-reconciliation.d.ts

@@ -3,6 +3,7 @@ import type { AuthorityState } from "../authority/transitions.ts";
 export type ReconciledState = Pick<AuthorityState, "runs" | "intents" | "details" | "gates" | "commands">;
 export interface WorkflowOutcome {
     readonly kind: string;
+    readonly promotionId?: string;
     readonly reason?: string;
     readonly issueUpdate?: "failed";
     readonly ticketStatus?: "complete" | "partial";

package/dist/src/host/world-reconciliation.js

@@ -14,6 +14,9 @@ async function withOutcome(ports, observed) {
         : {
             ...world,
             outcome: read.outcome.kind,
+            ...(read.outcome.promotionId === undefined
+                ? {}
+                : { promotionId: read.outcome.promotionId }),
             ...(read.outcome.issueUpdate === "failed"
                 ? { issueUpdate: read.outcome.issueUpdate }
                 : {}),

package/dist/src/host/world-runs.js

@@ -1,4 +1,5 @@
 import { isTicketStatus } from "../ticket-status.js";
+import { isPromotionId } from "../workflow-contracts.js";
 import { getRun } from "workflow/api";
 import { getWorld } from "workflow/runtime";
 export const runTag = "cloving.run";
@@ -47,8 +48,12 @@ export async function workflowOutcome(receipt) {
     const reason = Reflect.get(Object(value), "reason");
     const issueUpdate = Reflect.get(Object(value), "issueUpdate");
     const ticketStatus = Reflect.get(Object(value), "ticketStatus");
+    const promotionId = Reflect.get(Object(value), "promotionId");
     return {
         kind,
+        ...(kind === "handoff_requested" && isPromotionId(promotionId)
+            ? { promotionId }
+            : {}),
         ...(typeof reason === "string" ? { reason } : {}),
         ...(issueUpdate === "failed" ? { issueUpdate } : {}),
         ...(isTicketStatus(ticketStatus) ? { ticketStatus } : {}),

package/dist/src/issue-identity.d.ts

@@ -0,0 +1,6 @@
+export interface IssueIdentity {
+    readonly owner: string;
+    readonly repository: string;
+    readonly number: number;
+}
+export declare function issueIdentity(ticket: unknown): IssueIdentity | null;

package/dist/src/issue-identity.js

@@ -0,0 +1,23 @@
+export function issueIdentity(ticket) {
+    if (typeof ticket !== "string")
+        return null;
+    const markers = ticket
+        .split(/\r?\n/)
+        .filter((line) => line.startsWith("GitHub issue:"));
+    if (markers.length !== 1)
+        return null;
+    const match = /^GitHub issue: ([a-zA-Z0-9][a-zA-Z0-9-]*)\/([a-zA-Z0-9_.-]+)#([1-9][0-9]*)(?: \((?:open|closed)\))?\s*$/.exec(markers[0] ?? "");
+    const [, owner, repository, digits] = match ?? [];
+    const number = Number(digits);
+    if (owner === undefined ||
+        repository === undefined ||
+        [".", ".."].includes(repository) ||
+        !Number.isSafeInteger(number) ||
+        number <= 0)
+        return null;
+    return {
+        owner: owner.toLowerCase(),
+        repository: repository.toLowerCase(),
+        number,
+    };
+}

package/dist/src/service/queue-runs.d.ts

@@ -0,0 +1,3 @@
+import type { Reply } from "../protocol.ts";
+import { type ServiceContext } from "./replies.ts";
+export declare function queueRunStatuses(context: ServiceContext, runIds: unknown): Promise<Reply>;

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

@@ -0,0 +1,39 @@
+import { failed, invalidRequest, isIdentifier, result, } from "./replies.js";
+export async function queueRunStatuses(context, runIds) {
+    if (!Array.isArray(runIds) ||
+        runIds.length === 0 ||
+        runIds.length > 4 ||
+        !runIds.every(isIdentifier))
+        return invalidRequest("A queue status batch needs one to four run IDs.");
+    const state = await context.authority.state();
+    const runs = [];
+    for (const runId of runIds) {
+        const run = state.runs[runId];
+        if (run === undefined)
+            return failed("unknown-run", { detail: `No run has the ID ${runId}.` });
+        runs.push(await queuedRun(context, {
+            runId,
+            status: run.status,
+            sequence: state.sequence,
+        }));
+    }
+    return result("queue-run-statuses", { runs });
+}
+async function queuedRun(context, run) {
+    const event = await context.authority.queries.latestCompletion({
+        runId: run.runId,
+        atOrBefore: run.sequence,
+        terminal: true,
+    });
+    return {
+        runId: run.runId,
+        state: run.status,
+        terminalSequence: event?.sequence ?? null,
+        outcome: event?.type === "run.completed"
+            ? {
+                kind: event.payload["outcome"],
+                issueUpdate: event.payload["issueUpdate"],
+            }
+            : null,
+    };
+}

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

@@ -1,3 +1,4 @@
+import type { WorkflowStage, WorkflowStages } from "../workflow-declaration.ts";
 import type { SubmissionContract } from "../submission.ts";
 import type { ExecutionManifest } from "../workflow-admission.ts";
 export type Resolution = {
@@ -13,11 +14,13 @@ export interface ResolutionRequest {
     readonly submission: Readonly<Record<string, unknown>>;
     readonly commandId: string;
     readonly signal: AbortSignal;
+    readonly activeTickets?: readonly Readonly<Record<string, unknown>>[];
 }
 export interface Resolver {
     readonly id: string;
     readonly version: string;
     readonly resolve: (request: ResolutionRequest) => Promise<Resolution>;
+    readonly skippedTickets?: () => readonly Readonly<Record<string, unknown>>[];
 }
 export interface WorkflowRegistration {
     readonly workflowId: string;
@@ -26,15 +29,18 @@ export interface WorkflowRegistration {
     readonly submission: SubmissionContract;
     readonly resolver: Resolver;
     readonly effectLimit?: number;
-    readonly admission?: "when-idle";
+    readonly stages?: readonly WorkflowStage[];
+    readonly handoffs?: readonly string[];
+    readonly admission?: "when-idle" | number;
 }
 export interface Registered extends WorkflowRegistration {
     readonly pin: string;
 }
 export interface Registry {
     readonly workflowIds: readonly string[];
+    readonly workflowStages: WorkflowStages;
     readonly byId: (workflowId: string) => Registered | undefined;
     readonly byPin: (pin: string) => Registered | undefined;
     readonly available: (pinned: ExecutionManifest) => ExecutionManifest | undefined;
 }
-export declare function workflowRegistry(workflows: readonly WorkflowRegistration[]): Registry;
+export declare function workflowRegistry(workflows: readonly WorkflowRegistration[], retainedWorkflows?: readonly WorkflowRegistration[]): Registry;

package/dist/src/service/registry.js

@@ -1,13 +1,25 @@
 import { workflowPin } from "../broker/workflow-pin.js";
-export function workflowRegistry(workflows) {
-    const registered = workflows.map((workflow) => ({
+import { declaredManifest } from "../execution-pin.js";
+function registered(workflow) {
+    const manifest = declaredManifest(workflow.manifest, workflow);
+    return {
         ...workflow,
-        pin: workflowPin(workflow.manifest),
-    }));
+        ...(manifest.handoffs === undefined ? {} : { handoffs: manifest.handoffs }),
+        manifest,
+        pin: workflowPin(manifest),
+    };
+}
+export function workflowRegistry(workflows, retainedWorkflows = []) {
+    const current = workflows.map(registered);
+    const available = [...current, ...retainedWorkflows.map(registered)].filter((workflow) => workflow.availability === "available");
+    const byPin = (pin) => available.find((workflow) => workflow.pin === pin);
     return {
-        workflowIds: registered.map((workflow) => workflow.workflowId),
-        byId: (workflowId) => registered.find((workflow) => workflow.workflowId === workflowId),
-        byPin: (pin) => registered.find((workflow) => workflow.pin === pin),
-        available: (pinned) => registered.find((workflow) => workflow.manifest.workflowId === pinned.workflowId)?.manifest,
+        workflowIds: current.map((workflow) => workflow.workflowId),
+        workflowStages: Object.fromEntries(current.flatMap((workflow) => workflow.stages === undefined
+            ? []
+            : [[workflow.workflowId, workflow.stages]])),
+        byId: (workflowId) => current.find((workflow) => workflow.workflowId === workflowId),
+        byPin,
+        available: (pinned) => byPin(workflowPin(pinned))?.manifest,
     };
 }

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

@@ -3,9 +3,11 @@ import type { Fields, Reply } from "../protocol.ts";
 import type { ChangeSignal } from "./changes.ts";
 import type { Gateway } from "./gateway.ts";
 import type { Registry } from "./registry.ts";
+import type { WorkflowRefusal } from "../workflow-refusals.ts";
 export interface ServiceContext {
     readonly authority: Authority;
     readonly registry: Registry;
+    readonly workflowRefusals?: readonly WorkflowRefusal[];
     readonly gateway: Gateway;
     readonly clock: () => string;
     readonly livenessMilliseconds: number;