cloving 1.0.1 → 1.2.0

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

@@ -1,7 +1,12 @@
 import { join } from "node:path";
+import { ticketStatus } from "../ticket-status.js";
+import { sumPrices } from "../worker-usage.js";
+import { analysisWorker } from "./analysis-worker.js";
+import { analysisMethod } from "./analysis-launch.js";
 import { profileCommand, } from "../turn-profile.js";
-import { startTurn, } from "./claude-turn.js";
-import { interrupted, located as locatedIn, operationKey, readRecord as read, replied as repliedWith, reportOf, writeRecord as written, } from "./operation-journal.js";
+import {} from "./claude-turn.js";
+import { startRetriedTurn } from "./retrying-turn.js";
+import { interrupted, located, operationKey, readRecord as read, replied, reportOf, writeRecord as written, } from "./operation-journal.js";
 import { changes, treeFailure, workTree } from "./work-tree.js";
 export const claudeLimits = {
     summaryCharacters: 16_000,
@@ -9,9 +14,6 @@ export const claudeLimits = {
     stopMilliseconds: 2_000,
 };
 const worker = "claude";
-function located(settings, operationId) {
-    return locatedIn(settings.journal, operationId);
-}
 function alive(processId) {
     if (typeof processId !== "number")
         return false;
@@ -23,14 +25,11 @@ function alive(processId) {
         return Reflect.get(Object(error), "code") === "EPERM";
     }
 }
-function replied(key, recorded) {
-    return repliedWith({ receipt: key, worker }, recorded);
-}
 async function reconciled(parts, intent) {
-    const { key, folder } = located(parts.settings, intent.operationId);
+    const { key, folder } = located(parts.settings.journal, intent.operationId);
     const result = await read(folder, "result.json");
     if (result !== undefined)
-        return replied(key, result);
+        return replied({ receipt: key, worker }, result);
     if (parts.active.has(key))
         return { kind: "accepted", receipt: key, worker };
     const started = await read(folder, "started.json");
@@ -40,64 +39,73 @@ async function reconciled(parts, intent) {
         return { kind: "unknown", evidence: `claude-turn:${key}` };
     const ending = interrupted("claude-turn-interrupted");
     await written(folder, { name: "result.json", value: ending });
-    return replied(key, ending);
+    return replied({ receipt: key, worker }, ending);
 }
 async function resultText(tree, result) {
     const fields = {
+        ticketStatus: ticketStatus(result.text),
         summary: result.text.slice(0, claudeLimits.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,
     };
     const text = JSON.stringify(fields);
     const excess = Buffer.byteLength(text) - claudeLimits.resultBytes;
     if (excess <= 0)
-        return text;
+        return { text };
     const kept = Math.max(0, fields.summary.length - excess);
-    return JSON.stringify({ ...fields, summary: fields.summary.slice(0, kept) });
+    const shortened = JSON.stringify({
+        ...fields,
+        summary: fields.summary.slice(0, kept),
+    });
+    if (Buffer.byteLength(shortened) <= claudeLimits.resultBytes)
+        return { text: shortened };
+    const metadata = JSON.stringify({
+        ...fields,
+        ticketStatus: undefined,
+        summary: "",
+    });
+    return {
+        reason: "claude-result-too-large",
+        ...(Buffer.byteLength(metadata) <= claudeLimits.resultBytes
+            ? { text: metadata }
+            : {}),
+    };
 }
 async function outcome(running, end) {
     const endedAt = new Date().toISOString();
     const { result } = end;
-    const text = result === undefined ? undefined : await resultText(running.tree, result);
-    if (text !== undefined && end.exitCode === 0 && result?.failed === false)
+    const report = result === undefined ? {} : await resultText(running.tree, result);
+    const { text, reason } = report;
+    if (reason === undefined &&
+        text !== undefined &&
+        end.exitCode === 0 &&
+        result?.failed === false)
         return { outcome: "completed", result: text, endedAt };
     if (running.stopping.requested)
         return { outcome: "stopped", endedAt };
     return {
         outcome: "failed",
-        reason: "claude-turn-failed",
+        reason: reason ?? "claude-turn-failed",
         ...(text === undefined ? {} : { result: text }),
         endedAt,
     };
 }
-function reported(started, recorded) {
-    const { intent, key } = started;
-    return reportOf({ intent, commandId: `claude-turn:${key}`, worker }, recorded);
-}
 async function concluded(parts, running) {
+    const { intent, key } = running;
     const recorded = await outcome(running, await running.turn.ended);
     await written(running.folder, { name: "result.json", value: recorded });
-    await parts.settings.report(reported(running, recorded));
+    await parts.settings.report(reportOf({ intent, commandId: `claude-turn:${key}`, worker }, recorded));
 }
 async function begun(parts, start) {
     const { intent, key, folder, tree, prompt } = start;
-    const record = (processId) => written(folder, {
-        name: "started.json",
-        value: {
-            operationId: intent.operationId,
-            target: intent.target,
-            branch: tree.branch,
-            worktree: tree.path,
-            startCommit: tree.startCommit,
-            processId,
-            startedAt: new Date().toISOString(),
-        },
-    });
-    await record(null);
-    const turn = startTurn({
+    const turn = startRetriedTurn({
         worker: parts.settings.worker ?? "claude",
         command: profileCommand(parts.settings.command, start.profile),
         environment: start.profile.env ?? {},
@@ -105,16 +113,26 @@ async function begun(parts, start) {
         directory: tree.path,
         folder,
         prompt,
+    }, {
+        ...parts.settings,
+        metadata: {
+            operationId: intent.operationId,
+            target: intent.target,
+            branch: tree.branch,
+            worktree: tree.path,
+            startCommit: tree.startCommit,
+        },
     });
     const stopping = { requested: false };
     parts.active.set(key, {
         turn,
         stopping,
-        concluded: concluded(parts, { ...start, turn, stopping })
+        concluded: turn
+            .then((running) => concluded(parts, { ...start, turn: running, stopping }))
             .catch(() => undefined)
             .finally(() => parts.active.delete(key)),
     });
-    await record(turn.processId);
+    await turn;
 }
 async function firstTurn(settings, opening) {
     const { tree, intent } = opening;
@@ -171,8 +189,11 @@ async function selectedProfile(settings, intent) {
 async function delivered(parts, call) {
     const { intent, signal } = call;
     const { settings } = parts;
+    const aborted = () => signal.aborted;
     if (!turnIntent(intent))
         return failure("unsupported-effect");
+    if (aborted())
+        return failure("claude-start-aborted");
     const known = await reconciled(parts, intent);
     if (known.kind !== "absent")
         return known;
@@ -188,22 +209,25 @@ async function delivered(parts, call) {
         target: intent.target,
         signal,
     }).catch(treeFailure);
-    if (signal.aborted)
+    if (aborted())
         return failure("claude-start-aborted");
     if (typeof tree === "string")
         return failure(tree);
-    const place = located(settings, intent.operationId);
+    const place = located(settings.journal, intent.operationId);
     const first = await firstTurn(settings, { tree, intent });
+    if (aborted())
+        return failure("claude-start-aborted");
     await begun(parts, { ...place, intent, tree: first, prompt, profile });
     return { receipt: place.key, worker };
 }
 async function halted(parts, active) {
     active.stopping.requested = true;
-    active.turn.stop(parts.settings.stopMilliseconds ?? claudeLimits.stopMilliseconds);
+    const turn = await active.turn.catch(() => undefined);
+    turn?.stop(parts.settings.stopMilliseconds ?? claudeLimits.stopMilliseconds);
     await active.concluded;
 }
 async function stopped(parts, intent) {
-    const { key } = located(parts.settings, intent.operationId);
+    const { key } = located(parts.settings.journal, intent.operationId);
     const active = parts.active.get(key);
     if (active !== undefined)
         await halted(parts, active);
@@ -212,12 +236,35 @@ async function stopped(parts, intent) {
 export function claudeWorker(settings) {
     if (settings.command.length === 0)
         throw new Error("invalid-claude-command");
-    const parts = { settings, active: new Map() };
+    const parts = {
+        settings,
+        active: new Map(),
+        stopping: new AbortController(),
+    };
+    const analysis = analysisWorker(settings);
+    const guarded = async (intent, run) => {
+        if (!turnIntent(intent) ||
+            Object.hasOwn(settings.profiles ?? {}, "analyze-chats") ||
+            (await runWorkflow(settings, intent.runId)) !== "analyze-chats")
+            return failure("analysis-worker-unavailable");
+        return run();
+    };
     return {
-        deliver: (intent, signal) => delivered(parts, { intent, signal }),
-        reconcile: (intent) => reconciled(parts, intent),
-        stop: (intent) => stopped(parts, intent),
+        deliver: (intent, signal) => intent.method === analysisMethod
+            ? guarded(intent, () => analysis.deliver(intent, signal))
+            : delivered(parts, {
+                intent,
+                signal: AbortSignal.any([signal, parts.stopping.signal]),
+            }),
+        reconcile: (intent, signal) => intent.method === analysisMethod
+            ? guarded(intent, () => analysis.reconcile(intent, signal))
+            : reconciled(parts, intent),
+        stop: (intent, signal) => intent.method === analysisMethod
+            ? guarded(intent, () => analysis.stop(intent, signal))
+            : stopped(parts, intent),
         close: async () => {
+            parts.stopping.abort();
+            await analysis.close();
             await Promise.all([...parts.active.values()].map((active) => halted(parts, active)));
         },
     };

package/dist/src/daemon/codex-stream.js

@@ -1,3 +1,4 @@
+import { sumUsage, usageOf } from "../worker-usage.js";
 function record(value) {
     return typeof value === "object" && value !== null ? { ...value } : {};
 }
@@ -43,9 +44,20 @@ function completed(item) {
 }
 function updated(event, state) {
     const type = event["type"];
+    if (typeof type === "string" &&
+        ["thread.started", "turn.started", "turn.completed"].includes(type))
+        state.model = text(event["model"]) || state.model;
     if (type === "thread.started")
         state.sessionId = text(event["thread_id"]) || null;
     if (type === "turn.completed") {
+        const usage = record(event["usage"]);
+        const current = usageOf({
+            input_tokens: usage["input_tokens"],
+            cache_read_input_tokens: usage["cached_input_tokens"],
+            output_tokens: usage["output_tokens"],
+        });
+        state.usage =
+            state.turns === 0 ? current : sumUsage([state.usage, current]);
         state.turns += 1;
         state.error = null;
     }
@@ -82,8 +94,10 @@ function translated(event, state) {
 }
 export function codexStream() {
     const state = {
+        model: null,
         sessionId: null,
         turns: 0,
+        usage: usageOf(null),
         failure: null,
         error: null,
         message: "",
@@ -105,6 +119,8 @@ export function codexStream() {
                         state.error ||
                         `codex ended with the code ${String(exitCode)}`,
                 total_cost_usd: null,
+                ...(state.model === null ? {} : { model: state.model }),
+                usage: state.usage,
                 session_id: state.sessionId,
                 num_turns: state.turns,
             });

package/dist/src/daemon/daemon.d.ts

@@ -1,9 +1,13 @@
 import { type WorkflowFunction } from "../host/start-delivery.ts";
 import { type WorkflowHandler } from "../host/world-host.ts";
 import type { TurnProfiles } from "../turn-profile.ts";
+import type { TokenPrices } from "../token-prices.ts";
 import type { DeclaredWorkflow } from "../workflow-declaration.ts";
+import type { WorkflowRefusal } from "../workflow-refusals.ts";
 import type { Worker } from "./claude-turn.ts";
 export interface DaemonSettings {
+    readonly fallbackModels?: readonly string[];
+    readonly tokenPrices?: TokenPrices;
     readonly worker?: Worker;
     readonly profiles?: TurnProfiles;
     readonly directory: string;
@@ -11,6 +15,7 @@ export interface DaemonSettings {
     readonly repository: string;
     readonly manifests: Readonly<Record<string, string | undefined>>;
     readonly declarations?: readonly DeclaredWorkflow[];
+    readonly workflowRefusals?: readonly WorkflowRefusal[];
     readonly workflows: Readonly<Record<string, WorkflowFunction | undefined>>;
     readonly handler: WorkflowHandler;
     readonly command: readonly string[];
@@ -19,6 +24,8 @@ export interface DaemonSettings {
     readonly notifyCommand?: readonly string[];
     readonly notifyMilliseconds?: number;
     readonly queueMilliseconds?: number;
+    readonly queueLanes?: number;
+    readonly resetQueue?: boolean;
     readonly githubCommand?: readonly string[];
     readonly checkCommand?: readonly string[];
     readonly privateTexts?: readonly string[];
@@ -43,4 +50,4 @@ export declare const bridgeTiming: {
     pollMilliseconds: number;
     retryMilliseconds: number;
 };
-export declare function startDaemon(settings: DaemonSettings): Promise<DaemonOpening>;
+export declare function startDaemon(givenSettings: DaemonSettings): Promise<DaemonOpening>;

package/dist/src/daemon/daemon.js

@@ -1,4 +1,4 @@
-import { mkdir } from "node:fs/promises";
+import { mkdir, realpath } from "node:fs/promises";
 import { join } from "node:path";
 import { startDelivery, } from "../host/start-delivery.js";
 import { registerStepBridge, sdkStepCall, stepBridge, } from "../host/step-bridge-host.js";
@@ -6,9 +6,12 @@ import { startHost } from "../host/world-host.js";
 import { worldLoop } from "../host/world-reconciliation.js";
 import { cancelled, workflowOutcome, taggedRun, taggedRuns, } from "../host/world-runs.js";
 import { startService, } from "../service/service.js";
+import { workflowPin } from "../broker/workflow-pin.js";
 import { claudeWorker } from "./claude-worker.js";
 import { deliveryRouter } from "./delivery-router.js";
+import { handoffWorker } from "./handoff-worker.js";
 import { githubWorker } from "./github-worker.js";
+import { chatsWorker } from "./chats-worker.js";
 import { worldDirectory } from "./host-environment.js";
 import { issueQueue } from "./issue-queue.js";
 import { notifyRuns } from "./notify.js";
@@ -71,11 +74,17 @@ function githubOf(settings, given) {
 }
 function adapters(settings, options) {
     const { directory, repository, command } = settings;
-    const { given, table } = options;
-    const workflows = Object.fromEntries(table.map((row) => [row.workflowId, settings.workflows[row.functionName]]));
+    const { given, table, registrations } = options;
+    const functions = Object.fromEntries(table.map((row) => [row.workflowId, settings.workflows[row.functionName]]));
+    const workflows = Object.fromEntries(registrations.map((registration) => [
+        workflowPin(registration.manifest),
+        functions[registration.workflowId],
+    ]));
     const document = async (digest) => (await given).document(digest);
     const report = async (effect) => (await given).reportEffect(effect);
     const worker = claudeWorker({
+        fallbackModels: settings.fallbackModels ?? [],
+        tokenPrices: settings.tokenPrices ?? {},
         worker: settings.worker ?? "claude",
         profiles: settings.profiles ?? {},
         workflowId: async (runId) => (await given).workflowId(runId),
@@ -87,23 +96,46 @@ function adapters(settings, options) {
         journal: join(directory, "journal"),
     });
     const github = githubOf(settings, given);
+    const chats = chatsWorker({
+        runtimeDirectory: settings.runtimeDirectory,
+        document,
+        workflowId: async (runId) => (await given).workflowId(runId),
+    });
     const runs = startDelivery({
         document,
         runs: taggedRuns,
         cancel: cancelled,
         input: async (runId) => (await given).input(runId),
-        workflow: async (runId) => workflows[String(await (await given).workflowId(runId))],
+        workflow: ({ workflow }) => Promise.resolve(workflows[workflow]),
     });
-    return { worker, github, runs };
+    const handoff = handoffOf(settings, given);
+    return { worker, github, runs, chats, handoff };
 }
-export async function startDaemon(settings) {
-    const { directory } = settings;
+function handoffOf(settings, given) {
+    return handoffWorker({
+        runtimeDirectory: settings.runtimeDirectory,
+        journal: join(settings.directory, "handoffs"),
+        document: async (digest) => (await given).document(digest),
+        runStatus: async (runId) => (await (await given).state()).runs[runId]?.status,
+    });
+}
+async function daemonRegistrations(settings) {
     const table = ticketRegistrationTable({
         repository: settings.repository,
         command: settings.ticketCommand,
         nextCommand: settings.nextCommand,
+        githubCommand: settings.githubCommand,
     }, settings.declarations);
     const admitted = await ticketRegistrations(settings.manifests, { table });
+    return { table, admitted };
+}
+export async function startDaemon(givenSettings) {
+    const settings = {
+        ...givenSettings,
+        repository: await realpath(givenSettings.repository),
+    };
+    const { directory } = settings;
+    const { table, admitted } = await daemonRegistrations(settings);
     if (admitted.kind === "rejected")
         return {
             kind: "refused",
@@ -111,25 +143,27 @@ export async function startDaemon(settings) {
             detail: admitted.detail,
         };
     const given = Promise.withResolvers();
-    const { worker, github, runs } = adapters(settings, {
+    const { worker, github, runs, chats, handoff } = adapters(settings, {
         given: given.promise,
         table,
+        registrations: admitted.registrations,
     });
     await mkdir(join(directory, "state"), { recursive: true });
     await mkdir(settings.runtimeDirectory, { recursive: true, mode: 0o700 });
     const opening = await startService({
         stateDirectory: join(directory, "state"),
         runtimeDirectory: settings.runtimeDirectory,
+        workflowRefusals: settings.workflowRefusals ?? [],
         workflows: admitted.registrations.map((registration) => ({
             ...registration,
             ...(settings.queueMilliseconds !== undefined &&
                 registration.workflowId === "develop-issue"
-                ? { admission: "when-idle" }
+                ? { admission: settings.queueLanes ?? 1 }
                 : {}),
         })),
         delivery: deliveryRouter({
             runs,
-            effects: { claude: worker, github },
+            effects: { claude: worker, github, chats, handoff },
         }),
         effects: { leaseMilliseconds: turnLeaseMilliseconds },
         host: (ports) => {
@@ -138,7 +172,7 @@ export async function startDaemon(settings) {
         },
     });
     if (opening.kind === "refused") {
-        await Promise.all([worker.close(), github.close()]);
+        await Promise.all([worker.close(), github.close(), chats.close()]);
         return opening;
     }
     return {
@@ -147,11 +181,12 @@ export async function startDaemon(settings) {
             service: opening.service,
             worker,
             github,
+            chats,
         }),
     };
 }
 async function runningDaemon(settings, resources) {
-    const { service, worker, github } = resources;
+    const { service, worker, github, chats } = resources;
     await github.scan();
     const notifier = settings.notifyCommand === undefined
         ? undefined
@@ -163,7 +198,7 @@ async function runningDaemon(settings, resources) {
                 ? {}
                 : { intervalMilliseconds: settings.notifyMilliseconds }),
         }).catch(async (error) => {
-            await Promise.all([worker.close(), github.close()]);
+            await Promise.all([worker.close(), github.close(), chats.close()]);
             await service.close();
             throw error;
         });
@@ -173,13 +208,15 @@ async function runningDaemon(settings, resources) {
             directory: settings.directory,
             runtimeDirectory: settings.runtimeDirectory,
             intervalMilliseconds: settings.queueMilliseconds,
+            lanes: settings.queueLanes ?? 1,
+            resetQueue: settings.resetQueue ?? false,
         });
     return {
         socket: service.socket,
         close: async () => {
             await notifier?.stop();
             await queue?.stop();
-            await Promise.all([worker.close(), github.close()]);
+            await Promise.all([worker.close(), github.close(), chats.close()]);
             await service.close();
         },
     };

package/dist/src/daemon/delivery-router.js

@@ -25,6 +25,12 @@ export function deliveryRouter(routes) {
                 return runs.reconcile(intent);
             return workerOf(routes, intent)?.reconcile(intent, signal) ?? refusal();
         },
+        retry: (intent, signal) => {
+            if (!protectedEffect(intent))
+                return refusal();
+            return (workerOf(routes, intent)?.retry?.(intent, signal) ??
+                Promise.resolve({ kind: "unknown" }));
+        },
         stop: (intent, signal) => {
             if (!protectedEffect(intent))
                 return runs.stop(intent);

package/dist/src/daemon/github-calls.d.ts

@@ -24,6 +24,10 @@ export interface Finding {
     readonly line: number | null;
     readonly body: string;
 }
+export declare function githubText(text: string, settings: {
+    readonly environment?: NodeJS.ProcessEnv;
+    readonly privateTexts?: readonly string[];
+}): string;
 export declare function calls(settings: CallSettings, signal: AbortSignal): Calls;
 export declare function scoreOf(comments: unknown, commit: string): Scored | undefined;
 export declare function findingsOf(comments: unknown, commit: string): readonly Finding[];

package/dist/src/daemon/github-calls.js

@@ -22,17 +22,26 @@ function privateEnvironment(environment) {
 function failureDetail(error, place) {
     const stderr = field(error, "stderr");
     const text = typeof stderr === "string" ? stderr : "";
-    const secrets = Object.entries(place.environment)
+    return {
+        detail: githubText(text, place).slice(-2_000),
+        status: Number(/\(HTTP (\d{3})\)/.exec(text)?.[1]),
+    };
+}
+export function githubText(text, settings) {
+    const environment = { ...process.env, ...settings.environment };
+    const secrets = Object.entries(environment)
         .filter(([name]) => /TOKEN|SECRET|PASSWORD|KEY/i.test(name))
         .map(([, value]) => value);
-    const hidden = [...secrets, ...place.privateTexts]
+    const privateTexts = [
+        ...(settings.privateTexts ?? []),
+        ...privateEnvironment(environment),
+    ];
+    const hidden = [...secrets, ...privateTexts]
         .filter((value) => typeof value === "string" && value !== "")
         .sort((left, right) => right.length - left.length);
-    const detail = hidden.reduce((redacted, value) => redacted.replaceAll(value, "[hidden]"), text);
-    return {
-        detail: detail.slice(-2_000),
-        status: Number(/\(HTTP (\d{3})\)/.exec(text)?.[1]),
-    };
+    return hidden.reduce((redacted, value) => redacted.replaceAll(privateTexts.includes(value)
+        ? new RegExp(value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"), "gi")
+        : value, "[hidden]"), text);
 }
 async function output(command, place) {
     try {

package/dist/src/daemon/github-ci.d.ts

@@ -0,0 +1,6 @@
+import { type Operation } from "./github-operation.ts";
+export interface CiResult {
+    readonly reason: "ci-failed" | "ci-pending";
+    readonly output: string;
+}
+export declare function waitForCi(operation: Operation, commit: string): Promise<CiResult | undefined>;