cloving 1.1.0 → 1.3.0

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

@@ -1,10 +1,16 @@
+import { turnCommand } from "./turn-command.js";
 import { spawn } from "node:child_process";
 import { createWriteStream, mkdtempSync, rmSync } from "node:fs";
 import { join } from "node:path";
 import { codexStream } from "./codex-stream.js";
-import { priceOf, usageOf } from "../worker-usage.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 { geminiStream } from "./gemini-stream.js";
+import { priceOf, modelUsageOf, usageOf, } from "../worker-usage.js";
 import { commandModel } from "../token-prices.js";
-import { analysisCommand, analysisEnvironment } from "./analysis-launch.js";
+import { shellTurnScript } from "../agent-harness-shell.js";
 function parsed(line) {
     try {
         const value = JSON.parse(line);
@@ -20,21 +26,39 @@ function numberOf(value) {
 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 streamResult(line) {
+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")) }
             : {}),
@@ -48,6 +72,7 @@ export function streamResult(line) {
         model: textOf(field("model")),
         sessionId: textOf(field("session_id")),
         turns: numberOf(field("num_turns")),
+        ...(worker === "grok" ? grokResultFields(record) : {}),
     };
 }
 function ended(stream) {
@@ -55,12 +80,7 @@ function ended(stream) {
         stream.end(settle);
     });
 }
-function turnEnvironment(configuration, start) {
-    if (start.mode === "analysis")
-        return {
-            ...analysisEnvironment(start.folder),
-            CLAUDE_CODE_OAUTH_TOKEN: start.analysisToken,
-        };
+export function turnEnvironment(configuration, start) {
     const excluded = new Set([
         "GH_TOKEN",
         "GITHUB_TOKEN",
@@ -75,25 +95,42 @@ function turnEnvironment(configuration, start) {
     if (start.turnId !== undefined)
         environment["CLOVING_TURN_ID"] = start.turnId;
     environment["GH_CONFIG_DIR"] = configuration;
+    if (start.worker === "opencode")
+        environment["OPENCODE_PERMISSION"] = '{"*":"allow"}';
     return environment;
 }
 function spawnTurn(start) {
     const configuration = mkdtempSync(join(start.folder, "gh-config-"));
-    const [executable = "", ...fixed] = start.mode === "analysis" ? analysisCommand() : start.command;
+    const { parts, standardInput } = turnCommand(start);
+    const command = start.shell === undefined
+        ? parts
+        : [
+            start.shell,
+            "-l",
+            "-i",
+            "-c",
+            shellTurnScript,
+            "cloving-harness",
+            configuration,
+            ...parts,
+        ];
+    const [executable = "", ...fixed] = command;
     try {
         const child = spawn(executable, fixed, {
             cwd: start.directory,
             env: turnEnvironment(configuration, start),
             stdio: ["pipe", "pipe", "pipe"],
+            detached: start.shell !== undefined,
         });
-        return { child, configuration };
+        return { child, configuration, standardInput };
     }
     catch (error) {
         rmSync(configuration, { recursive: true, force: true });
         throw error;
     }
 }
-function receivedLines(stream, lines) {
+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);
@@ -102,7 +139,7 @@ function receivedLines(stream, lines) {
             stream.errorType = textOf(field("error"));
         if (type === "system" || type === "result")
             stream.model = textOf(field("model")) ?? stream.model;
-        const result = streamResult(line);
+        const result = streamResult(line, worker);
         if (result !== undefined) {
             const errorType = result.errorType ?? stream.errorType;
             stream.result = {
@@ -113,16 +150,31 @@ function receivedLines(stream, lines) {
     }
 }
 function activityOutput(start) {
-    if (start.mode === "analysis")
-        return undefined;
     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 turnOutput(start, stdout) {
+function streamAdapter(worker) {
+    if (worker === "codex")
+        return codexStream();
+    if (worker === "cursor-agent")
+        return cursorStream();
+    if (worker === "gemini")
+        return geminiStream();
+    return undefined;
+}
+function turnOutput(start, child) {
     const output = activityOutput(start);
-    const codex = start.worker === "codex" ? codexStream() : undefined;
+    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 = {
         pending: "",
         result: undefined,
@@ -130,66 +182,72 @@ function turnOutput(start, stdout) {
         errorType: null,
     };
     const received = (lines) => {
-        receivedLines(stream, lines);
+        receivedLines(stream, {
+            lines,
+            ...(start.worker === undefined ? {} : { worker: start.worker }),
+        });
     };
     const written = (lines) => {
         for (const line of lines)
-            output?.write(`${line}\n`);
+            output.write(`${line}\n`);
         received(lines);
     };
     stdout.setEncoding("utf8");
     stdout.on("data", (chunk) => {
-        if (codex === undefined)
-            output?.write(chunk);
+        if (adapter === undefined)
+            output.write(chunk);
         const lines = `${stream.pending}${chunk}`.split("\n");
         stream.pending = lines.pop() ?? "";
-        if (codex !== undefined) {
-            written(lines.flatMap(codex.line));
+        if (adapter !== undefined) {
+            written(lines.flatMap(adapter.line));
             return;
         }
         received(lines);
     });
     return async (exitCode) => {
-        if (codex !== undefined) {
-            written(codex.line(stream.pending));
-            written([codex.result(exitCode)]);
+        if (adapter !== undefined) {
+            written(adapter.line(stream.pending));
+            written([adapter.result(exitCode)]);
         }
-        if (output !== undefined)
-            await ended(output);
-        if (codex === undefined)
+        await ended(output);
+        if (adapter === undefined)
             received([stream.pending]);
         const result = stream.result;
         return result === undefined
             ? undefined
             : {
                 ...result,
-                model: result.model ??
-                    stream.model ??
-                    commandModel(start.mode === "analysis" ? analysisCommand() : start.command),
+                model: result.model ?? stream.model ?? commandModel(start.command),
             };
     };
 }
-function withoutAnalysisToken(start, result) {
-    const token = start.mode === "analysis" ? start.analysisToken : undefined;
-    if (token === undefined || result === undefined)
-        return result;
-    const redact = (value) => value === null ? null : value.replaceAll(token, "[redacted]");
-    return {
-        ...result,
-        text: redact(result.text) ?? "",
-        model: redact(result.model),
-        sessionId: redact(result.sessionId),
-    };
+function signalTurn(turn, signal) {
+    const { child, start } = turn;
+    if (start.shell === undefined || child.pid === undefined) {
+        child.kill(signal);
+        return;
+    }
+    try {
+        process.kill(-child.pid, signal);
+    }
+    catch (error) {
+        const code = Reflect.get(Object(error), "code");
+        if (code !== "ESRCH" && code !== "EPERM")
+            throw error;
+        child.kill(signal);
+    }
 }
 export function startTurn(start) {
-    const { child, configuration } = spawnTurn(start);
-    const output = turnOutput(start, child.stdout);
-    if (start.mode === "analysis")
-        child.stderr.resume();
-    else
-        child.stderr.pipe(createWriteStream(join(start.folder, "turn.stderr.log")));
+    const { child, configuration, standardInput } = spawnTurn(start);
+    const output = turnOutput(start, child);
+    const warnings = grokUsageWarnings();
+    if (start.worker === "grok") {
+        child.stderr.setEncoding("utf8");
+        child.stderr.on("data", warnings.write);
+    }
+    child.stderr.pipe(createWriteStream(join(start.folder, "turn.stderr.log")));
     child.stdin.on("error", () => undefined);
-    child.stdin.end(start.prompt);
+    child.stdin.end(standardInput);
     const closed = new Promise((settle) => {
         child.once("error", () => undefined);
         child.once("close", settle);
@@ -200,17 +258,22 @@ export function startTurn(start) {
         ended: closed
             .then(async (exitCode) => {
             timers.forEach(clearTimeout);
+            const result = await output(exitCode);
             return {
                 exitCode,
-                result: withoutAnalysisToken(start, await output(exitCode)),
+                result: result !== undefined && warnings.incomplete()
+                    ? { ...result, usage: usageOf(null), costUsd: null }
+                    : result,
             };
         })
             .finally(() => {
             rmSync(configuration, { recursive: true, force: true });
         }),
         stop: (graceMilliseconds) => {
-            child.kill("SIGTERM");
-            timers.push(setTimeout(() => child.kill("SIGKILL"), graceMilliseconds).unref());
+            signalTurn({ child, start }, "SIGTERM");
+            timers.push(setTimeout(() => {
+                signalTurn({ child, start }, "SIGKILL");
+            }, graceMilliseconds).unref());
         },
     };
 }

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

@@ -1,12 +1,9 @@
-import { type TokenPrices } from "../token-prices.ts";
+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 Worker } from "./claude-turn.ts";
 import { type RetrySettings } from "./retrying-turn.ts";
 import { type WorkerReport } from "./operation-journal.ts";
-export interface ClaudeWorkerSettings extends RetrySettings {
-    readonly tokenPrices?: TokenPrices;
-    readonly worker?: Worker;
+export interface ClaudeWorkerSettings extends RetrySettings, HarnessSettings {
     readonly profiles?: TurnProfiles;
     readonly workflowId?: (runId: string) => Promise<string | undefined>;
     readonly repository: string;
@@ -18,6 +15,7 @@ export interface ClaudeWorkerSettings extends RetrySettings {
     readonly stopMilliseconds?: number;
 }
 export interface ClaudeWorker extends Delivery {
+    readonly harness: (operationId: string) => Promise<string | undefined>;
     readonly stop: NonNullable<Delivery["stop"]>;
     readonly close: () => Promise<void>;
 }

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

@@ -1,19 +1,23 @@
 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 { turnHarness } from "../harness-defaults.js";
 import { profileCommand, } from "../turn-profile.js";
-import {} from "./claude-turn.js";
+import { succeeded } from "./claude-turn.js";
+import { turnReport } from "./turn-report.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";
+import { treeFailure, workTree } from "./work-tree.js";
 export const claudeLimits = {
     summaryCharacters: 16_000,
     resultBytes: 48_000,
     stopMilliseconds: 2_000,
 };
 const worker = "claude";
+async function recordedHarness(journal, operationId) {
+    const { folder } = located(journal, operationId);
+    const started = await read(folder, "started.json").catch(() => undefined);
+    const harness = Reflect.get(Object(started), "harness");
+    return typeof harness === "string" ? harness : undefined;
+}
 function alive(processId) {
     if (typeof processId !== "number")
         return false;
@@ -41,78 +45,43 @@ async function reconciled(parts, intent) {
     await written(folder, { name: "result.json", value: ending });
     return replied({ receipt: key, worker }, ending);
 }
-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 };
-    const kept = Math.max(0, fields.summary.length - excess);
-    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 report = result === undefined
         ? {}
-        : await resultText(running.tree, { result, settings: running.settings });
+        : await turnReport({
+            tree: running.tree,
+            harness: running.harness,
+            limits: claudeLimits,
+        }, result);
     const { text, reason } = report;
-    if (reason === undefined &&
-        text !== undefined &&
-        end.exitCode === 0 &&
-        result?.failed === false)
+    if (succeeded(end) && reason === undefined && text !== undefined)
         return { outcome: "completed", result: text, endedAt };
     if (running.stopping.requested)
         return { outcome: "stopped", endedAt };
     return {
         outcome: "failed",
-        reason: reason ?? "claude-turn-failed",
+        reason: end.reason ?? reason ?? "claude-turn-failed",
+        ...(end.detail === undefined ? {} : { detail: end.detail }),
         ...(text === undefined ? {} : { result: text }),
         endedAt,
     };
 }
 async function concluded(parts, running) {
     const { intent, key } = running;
-    const recorded = await outcome({ ...running, settings: parts.settings }, await running.turn.ended);
+    const recorded = await outcome(running, await running.turn.ended);
     await written(running.folder, { name: "result.json", value: 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 { harness } = start;
+    const stopping = { requested: false, controller: new AbortController() };
     const turn = startRetriedTurn({
-        worker: parts.settings.worker ?? "claude",
-        command: profileCommand(parts.settings.command, start.profile),
+        ...harness,
+        resultBytes: claudeLimits.resultBytes,
+        command: profileCommand(harness.command, start.profile),
         environment: start.profile.env ?? {},
         turnId: `${intent.runId}-${key}`,
         directory: tree.path,
@@ -120,7 +89,9 @@ async function begun(parts, start) {
         prompt,
     }, {
         ...parts.settings,
+        stopping: stopping.controller,
         metadata: {
+            harness: harness.worker,
             operationId: intent.operationId,
             target: intent.target,
             branch: tree.branch,
@@ -128,7 +99,6 @@ async function begun(parts, start) {
             startCommit: tree.startCommit,
         },
     });
-    const stopping = { requested: false };
     parts.active.set(key, {
         turn,
         stopping,
@@ -174,16 +144,30 @@ async function runWorkflow(settings, runId) {
         return undefined;
     }
 }
+function unsupportedProfile(profile, harness) {
+    if (harness.output === "text" && profile.model !== undefined)
+        return "profile-model-not-supported";
+    if (harness.worker === "claude")
+        return undefined;
+    return [
+        profile.allowedTools,
+        profile.permissionMode,
+        profile.maxBudgetUsd,
+    ].some((value) => value !== undefined)
+        ? "profile-needs-claude"
+        : undefined;
+}
 async function selectedProfile(settings, intent) {
     if (intent.method === "run-turn")
         return {};
-    if (settings.worker === "codex")
-        return "profile-needs-claude";
     const name = intent.method.slice("run-turn:".length);
     const profiles = settings.profiles ?? {};
     const profile = Object.hasOwn(profiles, name) ? profiles[name] : undefined;
     if (profile === undefined)
         return "unknown-profile";
+    const unsupported = unsupportedProfile(profile, turnHarness(settings, profile));
+    if (unsupported !== undefined)
+        return unsupported;
     if (profile.workflows === undefined)
         return profile;
     const workflowId = await runWorkflow(settings, intent.runId);
@@ -222,11 +206,19 @@ async function delivered(parts, call) {
     const first = await firstTurn(settings, { tree, intent });
     if (aborted())
         return failure("claude-start-aborted");
-    await begun(parts, { ...place, intent, tree: first, prompt, profile });
+    await begun(parts, {
+        ...place,
+        intent,
+        tree: first,
+        prompt,
+        profile,
+        harness: turnHarness(settings, profile),
+    });
     return { receipt: place.key, worker };
 }
 async function halted(parts, active) {
     active.stopping.requested = true;
+    active.stopping.controller.abort();
     const turn = await active.turn.catch(() => undefined);
     turn?.stop(parts.settings.stopMilliseconds ?? claudeLimits.stopMilliseconds);
     await active.concluded;
@@ -241,35 +233,27 @@ async function stopped(parts, intent) {
 export function claudeWorker(settings) {
     if (settings.command.length === 0)
         throw new Error("invalid-claude-command");
+    turnHarness(settings);
+    for (const profile of Object.values(settings.profiles ?? {}))
+        turnHarness(settings, profile);
     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();
-    };
+    const guarded = (intent, run) => intent.method === "run-turn:analyze-chats"
+        ? Promise.resolve(failure("unsupported-effect"))
+        : run();
     return {
-        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),
+        harness: (operationId) => recordedHarness(settings.journal, operationId),
+        deliver: (intent, signal) => guarded(intent, () => delivered(parts, {
+            intent,
+            signal: AbortSignal.any([signal, parts.stopping.signal]),
+        })),
+        reconcile: (intent) => guarded(intent, () => reconciled(parts, intent)),
+        stop: (intent) => guarded(intent, () => 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/command-journal.d.ts

@@ -0,0 +1,5 @@
+import type { CommandEffects } from "../command-settings.ts";
+export declare function claimCommand(folder: string): Promise<boolean>;
+export declare function commandStarted(folder: string): Promise<boolean>;
+export declare function recordCommandResult(folder: string, value: unknown): Promise<boolean>;
+export declare function commandEffects(journal: string): CommandEffects;

package/dist/src/daemon/command-journal.js

@@ -0,0 +1,50 @@
+import { randomUUID } from "node:crypto";
+import { link, mkdir, rm, stat, writeFile } from "node:fs/promises";
+import { dirname, join } from "node:path";
+import { located, readRecord } from "./operation-journal.js";
+import { record } from "../protocol.js";
+function alreadyExists(error) {
+    if (Reflect.get(Object(error), "code") === "EEXIST")
+        return false;
+    throw error;
+}
+export async function claimCommand(folder) {
+    await mkdir(dirname(folder), { recursive: true, mode: 0o700 });
+    return mkdir(folder, { mode: 0o700 }).then(() => true, alreadyExists);
+}
+export async function commandStarted(folder) {
+    return stat(folder).then(() => true, (error) => {
+        if (Reflect.get(Object(error), "code") === "ENOENT")
+            return false;
+        throw error;
+    });
+}
+export async function recordCommandResult(folder, value) {
+    const staged = join(folder, `${randomUUID()}.staged`);
+    await writeFile(staged, JSON.stringify(value), { mode: 0o600, flag: "wx" });
+    try {
+        return await link(staged, join(folder, "result.json")).then(() => true, alreadyExists);
+    }
+    finally {
+        await rm(staged);
+    }
+}
+export function commandEffects(journal) {
+    const completed = new Map();
+    return (effects) => Promise.all(effects.map(async (effect) => {
+        const { key, folder } = located(journal, effect.operationId);
+        const cached = completed.get(key);
+        if (cached !== undefined)
+            return { ...effect, ...cached };
+        const result = record(await readRecord(folder, "result.json"));
+        const exitCode = result?.["exitCode"];
+        const duration = result?.["durationMilliseconds"];
+        const metadata = {
+            exitCode: typeof exitCode === "number" ? exitCode : null,
+            durationMilliseconds: typeof duration === "number" ? duration : null,
+        };
+        if (result !== undefined)
+            completed.set(key, metadata);
+        return { ...effect, ...metadata };
+    }));
+}

package/dist/src/daemon/command-process.d.ts

@@ -0,0 +1,28 @@
+export interface CommandStart {
+    readonly command: readonly string[];
+    readonly directory: string;
+    readonly folder: string;
+    readonly payload: string;
+    readonly runId: string;
+    readonly operationId: string;
+    readonly seconds: number;
+    readonly deadline?: string;
+}
+export interface CommandEnd {
+    readonly stdout: string;
+    readonly exitCode: number | null;
+    readonly durationMilliseconds: number;
+    readonly reason?: string;
+}
+export interface RunningCommand {
+    readonly ended: Promise<CommandEnd>;
+    readonly stop: () => void;
+}
+export interface CommandClock {
+    readonly now: () => number;
+    readonly timer: (wait: {
+        readonly milliseconds: number;
+        readonly expired: () => void;
+    }) => () => void;
+}
+export declare function startCommand(start: CommandStart, clock?: CommandClock): RunningCommand;