cloving 1.0.1 → 1.1.0

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

@@ -1,7 +1,12 @@
 import { join } from "node:path";
+import { ticketStatus } from "../ticket-status.js";
+import { analysisWorker } from "./analysis-worker.js";
+import { analysisMethod } from "./analysis-launch.js";
+import { estimatedCostUsd, priceForModel, } from "../token-prices.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,78 @@ 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) {
+async function resultText(tree, turn) {
+    const { result, settings } = turn;
     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,
+        estimatedCostUsd: estimatedCostUsd(result.usage, {
+            worker: settings.worker ?? "claude",
+            price: priceForModel(settings.tokenPrices ?? {}, result.model),
+        }),
         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, settings: running.settings });
+    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 recorded = await outcome(running, await running.turn.ended);
+    const { intent, key } = running;
+    const recorded = await outcome({ ...running, settings: parts.settings }, 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 +118,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 +194,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 +214,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 +241,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,11 @@
 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 { Worker } from "./claude-turn.ts";
 export interface DaemonSettings {
+    readonly tokenPrices?: TokenPrices;
     readonly worker?: Worker;
     readonly profiles?: TurnProfiles;
     readonly directory: string;
@@ -19,6 +21,7 @@ export interface DaemonSettings {
     readonly notifyCommand?: readonly string[];
     readonly notifyMilliseconds?: number;
     readonly queueMilliseconds?: number;
+    readonly resetQueue?: boolean;
     readonly githubCommand?: readonly string[];
     readonly checkCommand?: readonly string[];
     readonly privateTexts?: readonly string[];

package/dist/src/daemon/daemon.js

@@ -9,6 +9,7 @@ import { startService, } from "../service/service.js";
 import { claudeWorker } from "./claude-worker.js";
 import { deliveryRouter } from "./delivery-router.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";
@@ -76,6 +77,7 @@ function adapters(settings, options) {
     const document = async (digest) => (await given).document(digest);
     const report = async (effect) => (await given).reportEffect(effect);
     const worker = claudeWorker({
+        tokenPrices: settings.tokenPrices ?? {},
         worker: settings.worker ?? "claude",
         profiles: settings.profiles ?? {},
         workflowId: async (runId) => (await given).workflowId(runId),
@@ -87,6 +89,11 @@ 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,
@@ -94,7 +101,7 @@ function adapters(settings, options) {
         input: async (runId) => (await given).input(runId),
         workflow: async (runId) => workflows[String(await (await given).workflowId(runId))],
     });
-    return { worker, github, runs };
+    return { worker, github, runs, chats };
 }
 export async function startDaemon(settings) {
     const { directory } = settings;
@@ -111,7 +118,7 @@ export async function startDaemon(settings) {
             detail: admitted.detail,
         };
     const given = Promise.withResolvers();
-    const { worker, github, runs } = adapters(settings, {
+    const { worker, github, runs, chats } = adapters(settings, {
         given: given.promise,
         table,
     });
@@ -129,7 +136,7 @@ export async function startDaemon(settings) {
         })),
         delivery: deliveryRouter({
             runs,
-            effects: { claude: worker, github },
+            effects: { claude: worker, github, chats },
         }),
         effects: { leaseMilliseconds: turnLeaseMilliseconds },
         host: (ports) => {
@@ -138,7 +145,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 +154,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 +171,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 +181,14 @@ async function runningDaemon(settings, resources) {
             directory: settings.directory,
             runtimeDirectory: settings.runtimeDirectory,
             intervalMilliseconds: settings.queueMilliseconds,
+            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/github-methods.js

@@ -1,5 +1,6 @@
 import { setTimeout as delay } from "node:timers/promises";
 import { findingsOf, scoreOf } from "./github-calls.js";
+import { closeIssue, partialIssue } from "./github-ticket-status.js";
 import { merge } from "./github-merge.js";
 import { createIssue, discard } from "./github-issue-methods.js";
 import { existingTree, defaultBranch, changeChecked, field, githubTiming, repositoryPath, text, } from "./github-operation.js";
@@ -11,6 +12,7 @@ export const methodReasons = new Set([
     "post-uncertain",
     "private-texts-not-set",
     "github-call-failed",
+    "github-issue-conflict",
     "git-call-failed",
     "check-failed",
     "merge-conflict",
@@ -183,6 +185,8 @@ async function waitReview(operation) {
 }
 export const methods = new Map([
     ["prepare", prepare],
+    ["close-issue", closeIssue],
+    ["partial-issue", partialIssue],
     ["label", label],
     ["create-issue", createIssue],
     ["discard", discard],

package/dist/src/daemon/github-ticket-status.d.ts

@@ -0,0 +1,3 @@
+import { type Operation } from "./github-operation.ts";
+export declare function closeIssue(operation: Operation): Promise<unknown>;
+export declare function partialIssue(operation: Operation): Promise<unknown>;