cloving 1.3.0 → 1.5.0

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

@@ -0,0 +1,208 @@
+import { usageOf, priceOf } from "../worker-usage.js";
+import { located, readRecord, writeRecord, interrupted, replied, reportOf, } from "./operation-journal.js";
+import { turnHarness } from "../harness-defaults.js";
+import { selectedProfile } from "./worker-profile.js";
+import { recordedProcessDirectory } from "./worktree-processes.js";
+import { resumeWorktree } from "./resume-worktree.js";
+export const resumePrompt = "This turn stopped because the Cloving daemon restarted. Continue the task from the point where it stopped. Run again each command or subagent that did not end. End with the result line that the task asks for.";
+export function turnIntent(intent) {
+    return (intent.capability === "claude" &&
+        intent.method !== "run-turn:analyze-chats" &&
+        (intent.method === "run-turn" ||
+            /^run-turn:[A-Za-z0-9_-]{1,119}$/.test(intent.method ?? "")) &&
+        intent.target !== undefined &&
+        intent.payload !== undefined &&
+        intent.leaseGeneration !== undefined);
+}
+export function resumableHarness(harness) {
+    return harness === "claude" || harness === "codex";
+}
+export function resumedCommand(request) {
+    const { worker = "claude", command, sessionId } = request;
+    if (worker === "codex")
+        return codexResume(command, sessionId);
+    if (worker !== "claude")
+        return undefined;
+    const separator = command.indexOf("--");
+    const boundary = separator < 0 ? command.length : separator;
+    return [
+        ...command.slice(0, boundary),
+        "--resume",
+        sessionId,
+        ...command.slice(boundary),
+    ];
+}
+function codexResume(command, sessionId) {
+    const exec = command.indexOf("exec");
+    if (exec < 0)
+        return undefined;
+    return [
+        ...command.slice(0, exec + 1),
+        "resume",
+        sessionId,
+        ...command.slice(exec + 1),
+    ];
+}
+export function recordedField(value, name) {
+    if (typeof value !== "object" || value === null)
+        return undefined;
+    return Reflect.get(value, name);
+}
+export function processAlive(processId) {
+    if (typeof processId !== "number")
+        return false;
+    try {
+        process.kill(processId, 0);
+        return true;
+    }
+    catch (error) {
+        return recordedField(error, "code") === "EPERM";
+    }
+}
+export async function uncertainProcess(started) {
+    const processId = recordedField(started, "processId");
+    if (typeof processId !== "number" || !processAlive(processId))
+        return false;
+    return (!resumableHarness(recordedField(started, "harness")) ||
+        (await recordedProcessDirectory(processId)) === undefined);
+}
+export function recordedTree(started) {
+    const path = recordedField(started, "worktree");
+    const branch = recordedField(started, "branch");
+    const startCommit = recordedField(started, "startCommit");
+    return typeof path === "string" &&
+        typeof branch === "string" &&
+        typeof startCommit === "string"
+        ? { path, branch, startCommit }
+        : undefined;
+}
+export async function resumePlan(settings, request) {
+    const { folder, started, intent, signal } = request;
+    const tree = recordedTree(started);
+    if (tree === undefined)
+        return "claude-turn-interrupted";
+    const locked = await resumeWorktree({
+        ...settings,
+        directory: tree.path,
+        folder,
+        signal,
+    });
+    if (locked !== null)
+        return locked.reason;
+    const resume = await readResume(folder, started);
+    if (resume === undefined)
+        return "claude-turn-interrupted";
+    const profile = await selectedProfile(settings, intent);
+    if (typeof profile === "string")
+        return "claude-turn-interrupted";
+    const harness = turnHarness(settings, profile);
+    if (recordedField(started, "harness") !== harness.worker ||
+        resumedCommand({
+            worker: harness.worker,
+            command: harness.command,
+            sessionId: resume.sessionId,
+        }) === undefined)
+        return "claude-turn-interrupted";
+    return { resume, tree, profile, harness };
+}
+function priorEnd(record) {
+    const field = (name) => recordedField(record, name);
+    const sessionId = field("sessionId");
+    const model = field("model");
+    const retryKind = field("retryKind");
+    return {
+        ...(retryKind === "capacity" ||
+            retryKind === "network" ||
+            retryKind === null
+            ? { retryKind }
+            : {}),
+        ...(field("resumedAfter") === "daemon-restart"
+            ? { resumedAfter: "daemon-restart" }
+            : {}),
+        exitCode: null,
+        result: {
+            sessionId: typeof sessionId === "string" ? sessionId : null,
+            model: typeof model === "string" ? model : null,
+            text: "",
+            failed: true,
+            costUsd: recordedSessionCost(record),
+            turns: typeof field("turns") === "number" ? Number(field("turns")) : null,
+            usage: usageOf(field("usage")),
+        },
+    };
+}
+function recordedSessionCost(record) {
+    const fields = typeof record === "object" && record !== null ? record : {};
+    const name = Object.hasOwn(fields, "sessionCostUsd")
+        ? "sessionCostUsd"
+        : "costUsd";
+    return priceOf(Reflect.get(fields, name));
+}
+function resumeHeader(started) {
+    if (recordedField(started, "phase") === "waiting")
+        return undefined;
+    const attempt = recordedField(started, "attempt");
+    const startedAt = recordedField(started, "startedAt");
+    const head = recordedField(started, "turnStartCommit");
+    if (typeof attempt !== "number" ||
+        !Number.isSafeInteger(attempt) ||
+        attempt < 1 ||
+        attempt > 5 ||
+        typeof startedAt !== "string")
+        return undefined;
+    return {
+        attempt,
+        startedAt,
+        turnStartCommit: typeof head === "string" ? head : null,
+    };
+}
+export async function readResume(folder, started) {
+    const header = resumeHeader(started);
+    if (header === undefined)
+        return undefined;
+    const records = [];
+    for (let number = 1; number <= header.attempt; number += 1)
+        records.push(await readRecord(folder, `attempt-${String(number)}.json`));
+    const sessionId = recordedField(records.at(-1), "sessionId");
+    if (typeof sessionId !== "string" ||
+        sessionId === "" ||
+        records.filter((record) => recordedField(record, "resumedAfter") === "daemon-restart").length >= 2)
+        return undefined;
+    return {
+        sessionId,
+        ends: records.map(priorEnd),
+        startedAt: header.startedAt,
+        turnStartCommit: header.turnStartCommit,
+    };
+}
+export async function recordedHarness(journal, operationId) {
+    const { folder } = located(journal, operationId);
+    const started = await readRecord(folder, "started.json").catch(() => undefined);
+    const harness = recordedField(started, "harness");
+    return typeof harness === "string" ? harness : undefined;
+}
+export async function interruptedReply(place, reason) {
+    const ending = interrupted(reason);
+    await writeRecord(place.folder, { name: "result.json", value: ending });
+    return replied({ receipt: place.key, worker: "claude" }, ending);
+}
+export async function recoverTurn(operation, reconcile) {
+    const { intent, journal, report } = operation;
+    if (!resumableHarness(await recordedHarness(journal, intent.operationId)))
+        return;
+    const result = await reconcile();
+    if (operation.signal.aborted)
+        return;
+    if (result.kind === "completed" ||
+        result.kind === "failed" ||
+        result.kind === "stopped")
+        await report(reportOf({
+            intent,
+            worker: "claude",
+            commandId: `claude-turn:${located(journal, intent.operationId).key}`,
+        }, {
+            ...result,
+            outcome: result.kind,
+            endedAt: new Date().toISOString(),
+        }));
+}

package/dist/src/daemon/claude-stream.d.ts

@@ -0,0 +1,27 @@
+import type { ReviewVerdict } from "../review-subject.ts";
+import type { TicketStatus } from "../ticket-status.ts";
+import { type WorkerUsage, type WorkerAttemptUsage, type WorkerModelUsage, type RetryKind } from "../worker-usage.ts";
+export type Worker = string;
+export interface StreamResult {
+    readonly reviewFeedback?: string;
+    readonly reviewVerdict?: ReviewVerdict | null;
+    readonly models?: readonly WorkerModelUsage[];
+    readonly ticketStatusTooLarge?: true;
+    readonly ticketStatus?: TicketStatus;
+    readonly attempts?: readonly WorkerAttemptUsage[];
+    readonly pricingModel?: string | null;
+    readonly subtype?: string;
+    readonly errorType?: string;
+    readonly model: string | null;
+    readonly text: string;
+    readonly failed: boolean;
+    readonly costUsd: number | null;
+    readonly usage: WorkerUsage;
+    readonly sessionId: string | null;
+    readonly turns: number | null;
+}
+export declare function parsed(line: string): unknown;
+export declare function textOf(value: unknown): string | null;
+export declare function capacityRefusal(result: StreamResult | undefined): boolean;
+export declare function retryKind(result: StreamResult | undefined): RetryKind | null;
+export declare function streamResult(line: string, worker?: Worker): StreamResult | undefined;

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

@@ -0,0 +1,63 @@
+import { grokResultFields } from "../grok-result.js";
+import { priceOf, modelUsageOf, usageOf, } from "../worker-usage.js";
+export function parsed(line) {
+    try {
+        const value = JSON.parse(line);
+        return value;
+    }
+    catch {
+        return undefined;
+    }
+}
+function numberOf(value) {
+    return typeof value === "number" ? value : null;
+}
+export function textOf(value) {
+    return typeof value === "string" ? value : null;
+}
+function networkFailure(result) {
+    return (result?.failed === true &&
+        result.text.startsWith("API Error: Can't reach the API server"));
+}
+export function capacityRefusal(result) {
+    if (networkFailure(result))
+        return false;
+    return (result?.failed === true &&
+        ["success", "error_during_execution"].includes(result.subtype ?? "error_during_execution") &&
+        (result.text ===
+            "Selected model is at capacity. Please try a different model." ||
+            result.errorType === "overloaded"));
+}
+export function retryKind(result) {
+    if (networkFailure(result))
+        return "network";
+    return capacityRefusal(result) ? "capacity" : null;
+}
+export function streamResult(line, worker) {
+    if (!line.includes('"result"'))
+        return undefined;
+    const record = parsed(line);
+    if (typeof record !== "object" || record === null)
+        return undefined;
+    const field = (name) => Reflect.get(record, name);
+    if (field("type") !== "result")
+        return undefined;
+    const models = modelUsageOf(field("models"));
+    return {
+        ...(models === undefined ? {} : { models }),
+        ...(typeof field("subtype") === "string"
+            ? { subtype: String(field("subtype")) }
+            : {}),
+        ...(typeof field("error") === "string"
+            ? { errorType: String(field("error")) }
+            : {}),
+        text: textOf(field("result")) ?? "",
+        failed: field("is_error") === true,
+        costUsd: priceOf(field("total_cost_usd")),
+        usage: usageOf(field("usage")),
+        model: textOf(field("model")),
+        sessionId: textOf(field("session_id")),
+        turns: numberOf(field("num_turns")),
+        ...(worker === "grok" ? grokResultFields(record) : {}),
+    };
+}

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

@@ -1,26 +1,10 @@
-import type { ReviewVerdict } from "../review-subject.ts";
-import type { TicketStatus } from "../ticket-status.ts";
-import { type WorkerUsage, type WorkerAttemptUsage, type WorkerModelUsage, type RetryKind } from "../worker-usage.ts";
-export type Worker = string;
-export interface StreamResult {
-    readonly reviewFeedback?: string;
-    readonly reviewVerdict?: ReviewVerdict | null;
-    readonly models?: readonly WorkerModelUsage[];
-    readonly ticketStatusTooLarge?: true;
-    readonly ticketStatus?: TicketStatus;
-    readonly attempts?: readonly WorkerAttemptUsage[];
-    readonly pricingModel?: string | null;
-    readonly subtype?: string;
-    readonly errorType?: string;
-    readonly model: string | null;
-    readonly text: string;
-    readonly failed: boolean;
-    readonly costUsd: number | null;
-    readonly usage: WorkerUsage;
-    readonly sessionId: string | null;
-    readonly turns: number | null;
-}
+import { type Worker, type StreamResult } from "./claude-stream.ts";
+import { type RetryKind } from "../worker-usage.ts";
+export { streamResult, capacityRefusal, retryKind } from "./claude-stream.ts";
+export type { Worker, StreamResult } from "./claude-stream.ts";
 export interface TurnEnd {
+    readonly retryKind?: RetryKind | null;
+    readonly resumedAfter?: "daemon-restart";
     readonly reason?: string;
     readonly detail?: string;
     readonly stopped?: boolean;
@@ -28,6 +12,7 @@ export interface TurnEnd {
     readonly result: StreamResult | undefined;
 }
 export interface TurnStart {
+    readonly progress?: (progress: TurnProgress) => Promise<void>;
     readonly resultBytes?: number;
     readonly output?: "text";
     readonly shell?: string;
@@ -40,14 +25,15 @@ export interface TurnStart {
     readonly activityFolder?: string;
     readonly prompt: string;
 }
+export interface TurnProgress {
+    readonly sessionId: string | null;
+    readonly result: StreamResult | undefined;
+}
 export interface RunningTurn {
     readonly processId: number | null;
     readonly ended: Promise<TurnEnd>;
     readonly stop: (graceMilliseconds: number) => void;
 }
-export declare function capacityRefusal(result: StreamResult | undefined): boolean;
-export declare function retryKind(result: StreamResult | undefined): RetryKind | null;
 export declare function succeeded(end: TurnEnd): boolean;
-export declare function streamResult(line: string, worker?: Worker): StreamResult | undefined;
 export declare function turnEnvironment(configuration: string, start: TurnStart): NodeJS.ProcessEnv;
 export declare function startTurn(start: TurnStart): RunningTurn;

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

@@ -6,75 +6,18 @@ import { codexStream } from "./codex-stream.js";
 import { cursorStream } from "./cursor-stream.js";
 import { opencodeStream } from "./opencode-stream.js";
 import { textOutput } from "./text-output.js";
-import { grokResultFields, grokUsageWarnings } from "../grok-result.js";
+import { grokUsageWarnings } from "../grok-result.js";
 import { geminiStream } from "./gemini-stream.js";
-import { priceOf, modelUsageOf, usageOf, } from "../worker-usage.js";
+import { parsed, textOf, streamResult, } from "./claude-stream.js";
+import { usageOf } from "../worker-usage.js";
+export { streamResult, capacityRefusal, retryKind } from "./claude-stream.js";
 import { commandModel } from "../token-prices.js";
 import { shellTurnScript } from "../agent-harness-shell.js";
-function parsed(line) {
-    try {
-        const value = JSON.parse(line);
-        return value;
-    }
-    catch {
-        return undefined;
-    }
-}
-function numberOf(value) {
-    return typeof value === "number" ? value : null;
-}
-function textOf(value) {
-    return typeof value === "string" ? value : null;
-}
-function networkFailure(result) {
-    return (result?.failed === true &&
-        result.text.startsWith("API Error: Can't reach the API server"));
-}
-export function capacityRefusal(result) {
-    if (networkFailure(result))
-        return false;
-    return (result?.failed === true &&
-        ["success", "error_during_execution"].includes(result.subtype ?? "error_during_execution") &&
-        (result.text ===
-            "Selected model is at capacity. Please try a different model." ||
-            result.errorType === "overloaded"));
-}
-export function retryKind(result) {
-    if (networkFailure(result))
-        return "network";
-    return capacityRefusal(result) ? "capacity" : null;
-}
 export function succeeded(end) {
     return (end.reason === undefined &&
         end.exitCode === 0 &&
         end.result?.failed === false);
 }
-export function streamResult(line, worker) {
-    if (!line.includes('"result"'))
-        return undefined;
-    const record = parsed(line);
-    const field = (name) => Reflect.get(Object(record), name);
-    if (field("type") !== "result")
-        return undefined;
-    const models = modelUsageOf(field("models"));
-    return {
-        ...(models === undefined ? {} : { models }),
-        ...(typeof field("subtype") === "string"
-            ? { subtype: String(field("subtype")) }
-            : {}),
-        ...(typeof field("error") === "string"
-            ? { errorType: String(field("error")) }
-            : {}),
-        text: textOf(field("result")) ?? "",
-        failed: field("is_error") === true,
-        costUsd: priceOf(field("total_cost_usd")),
-        usage: usageOf(field("usage")),
-        model: textOf(field("model")),
-        sessionId: textOf(field("session_id")),
-        turns: numberOf(field("num_turns")),
-        ...(worker === "grok" ? grokResultFields(record) : {}),
-    };
-}
 function ended(stream) {
     return new Promise((settle) => {
         stream.end(settle);
@@ -129,33 +72,65 @@ function spawnTurn(start) {
         throw error;
     }
 }
+function streamMetadata(stream, event) {
+    if (typeof event !== "object" || event === null)
+        return false;
+    const field = (name) => Reflect.get(event, name);
+    const type = field("type");
+    const sessionId = textOf(field("session_id"));
+    const discovered = stream.sessionId === null && sessionId !== null;
+    if (discovered)
+        stream.sessionId = sessionId;
+    if (type === "assistant" && field("parent_tool_use_id") == null)
+        stream.errorType = textOf(field("error"));
+    if (type === "system" || type === "result")
+        stream.model = textOf(field("model")) ?? stream.model;
+    return discovered;
+}
 function receivedLines(stream, input) {
     const { lines, worker } = input;
     for (const line of lines) {
-        const event = parsed(line);
-        const field = (name) => Reflect.get(Object(event), name);
-        const type = field("type");
-        if (type === "assistant" && field("parent_tool_use_id") == null)
-            stream.errorType = textOf(field("error"));
-        if (type === "system" || type === "result")
-            stream.model = textOf(field("model")) ?? stream.model;
+        const discovered = streamMetadata(stream, parsed(line));
         const result = streamResult(line, worker);
         if (result !== undefined) {
             const errorType = result.errorType ?? stream.errorType;
             stream.result = {
                 ...result,
+                sessionId: result.sessionId ?? stream.sessionId,
                 ...(errorType === null ? {} : { errorType }),
             };
         }
+        if (discovered || result !== undefined) {
+            saveProgress(stream, input);
+        }
     }
 }
+function saveProgress(stream, input) {
+    const progress = { sessionId: stream.sessionId, result: stream.result };
+    stream.saved = stream.saved
+        .then(() => {
+        if (stream.failure === undefined)
+            return input.progress?.(progress);
+        return undefined;
+    })
+        .catch((error) => {
+        stream.failure = { error };
+        input.failed();
+    });
+}
 function activityOutput(start) {
     const output = createWriteStream(join(start.activityFolder ?? start.folder, "turn.jsonl"), { flags: start.activityFolder === undefined ? "w" : "a" });
     if (start.activityFolder !== undefined)
         output.write("\n");
     return output;
 }
-function streamAdapter(worker) {
+function streamAdapter(worker, stderr) {
+    if (worker === "opencode") {
+        const translated = opencodeStream();
+        stderr.setEncoding("utf8");
+        stderr.on("data", translated.stderr);
+        return translated;
+    }
     if (worker === "codex")
         return codexStream();
     if (worker === "cursor-agent")
@@ -164,26 +139,31 @@ function streamAdapter(worker) {
         return geminiStream();
     return undefined;
 }
-function turnOutput(start, child) {
-    const output = activityOutput(start);
-    if (start.output === "text")
-        return textOutput(child, { output, limit: start.resultBytes ?? 48_000 });
-    const translated = start.worker === "opencode" ? opencodeStream() : undefined;
-    const adapter = translated ?? streamAdapter(start.worker);
-    const { stdout, stderr } = child;
-    if (translated !== undefined) {
-        stderr.setEncoding("utf8");
-        stderr.on("data", translated.stderr);
-    }
-    const stream = {
+function streamState() {
+    return {
+        failure: undefined,
+        sessionId: null,
+        saved: Promise.resolve(),
         pending: "",
         result: undefined,
         model: null,
         errorType: null,
     };
+}
+function turnOutput(start, child) {
+    const output = activityOutput(start);
+    if (start.output === "text")
+        return textOutput(child, { output, limit: start.resultBytes ?? 48_000 });
+    const { stdout, stderr } = child;
+    const adapter = streamAdapter(start.worker, stderr);
+    const stream = streamState();
     const received = (lines) => {
         receivedLines(stream, {
             lines,
+            progress: start.progress,
+            failed: () => {
+                signalTurn({ child, start }, "SIGKILL");
+            },
             ...(start.worker === undefined ? {} : { worker: start.worker }),
         });
     };
@@ -212,6 +192,9 @@ function turnOutput(start, child) {
         await ended(output);
         if (adapter === undefined)
             received([stream.pending]);
+        await stream.saved;
+        if (stream.failure !== undefined)
+            throw stream.failure.error;
         const result = stream.result;
         return result === undefined
             ? undefined

package/dist/src/daemon/claude-worker.d.ts

@@ -1,10 +1,10 @@
 import { type HarnessSettings } from "../harness-defaults.ts";
-import { type TurnProfiles } from "../turn-profile.ts";
-import type { Delivery } from "../broker/actor/delivery-intents.ts";
+import type { Delivery, DeliveryIntent } from "../broker/actor/delivery-intents.ts";
 import { type RetrySettings } from "./retrying-turn.ts";
 import { type WorkerReport } from "./operation-journal.ts";
-export interface ClaudeWorkerSettings extends RetrySettings, HarnessSettings {
-    readonly profiles?: TurnProfiles;
+import type { TurnSettings } from "../project-settings.ts";
+export interface ClaudeWorkerSettings extends Pick<RetrySettings, "retryDelay">, HarnessSettings {
+    readonly turnSettings: () => TurnSettings;
     readonly workflowId?: (runId: string) => Promise<string | undefined>;
     readonly repository: string;
     readonly worktrees: string;
@@ -15,6 +15,7 @@ export interface ClaudeWorkerSettings extends RetrySettings, HarnessSettings {
     readonly stopMilliseconds?: number;
 }
 export interface ClaudeWorker extends Delivery {
+    readonly recover: (intent: DeliveryIntent) => Promise<void>;
     readonly harness: (operationId: string) => Promise<string | undefined>;
     readonly stop: NonNullable<Delivery["stop"]>;
     readonly close: () => Promise<void>;