cloving 1.0.1 → 1.1.0

package/dist/src/daemon/chats-files.js

@@ -0,0 +1,113 @@
+import { lstat } from "node:fs/promises";
+import { dirname, join, resolve } from "node:path";
+import { openInput } from "../chats/input-file.js";
+import { createPrivateFile, validateDestination, } from "../chats/destination.js";
+import { analysisDocumentBytes, } from "../chats/analysis-input.js";
+export async function analysisDirectory(runtime, importId) {
+    if (process.platform !== "darwin")
+        throw new Error("platform-unsupported");
+    const directory = resolve(runtime, "chats", importId);
+    await checkedDirectory(directory);
+    return directory;
+}
+async function checkedDirectory(directory) {
+    try {
+        if (!(await lstat(directory)).isDirectory())
+            throw new Error("analysis-input-refused");
+    }
+    catch (error) {
+        if (Reflect.get(Object(error), "code") !== "ENOENT")
+            throw error;
+        const parent = dirname(directory);
+        if (parent === directory)
+            throw error;
+        await checkedDirectory(parent);
+        throw error;
+    }
+    await validateDestination(directory);
+}
+export async function boundedAnalysisFile(path, options = {}) {
+    const handle = await openInput(path);
+    try {
+        if (options.permissions !== undefined &&
+            ((await handle.stat()).mode & 0o777) !== options.permissions)
+            throw new Error("analysis-output-failed");
+        const buffer = Buffer.alloc(analysisDocumentBytes + 1);
+        let size = 0;
+        while (size < buffer.length) {
+            const { bytesRead } = await handle.read(buffer, size, buffer.length - size, null);
+            if (bytesRead === 0)
+                break;
+            size += bytesRead;
+        }
+        if (size > analysisDocumentBytes)
+            throw new Error("analysis-too-large");
+        return new TextDecoder("utf-8", { fatal: true, ignoreBOM: true }).decode(buffer.subarray(0, size));
+    }
+    finally {
+        await handle.close();
+    }
+}
+export async function readAnalysisSnapshot(directory, importId) {
+    const required = async (name) => {
+        try {
+            return await boundedAnalysisFile(join(directory, name));
+        }
+        catch (error) {
+            if (Reflect.get(Object(error), "code") === "ENOENT")
+                throw new Error("redaction-required", { cause: error });
+            throw error;
+        }
+    };
+    return {
+        importId,
+        redaction: await required("redaction.json"),
+        corpus: await required("redacted.jsonl"),
+        structure: await boundedAnalysisFile(join(directory, "structure.json")),
+    };
+}
+export async function matchingPrivateFile(path, text) {
+    try {
+        const existing = await boundedAnalysisFile(path, { permissions: 0o600 });
+        if (existing !== text)
+            throw new Error("analysis-output-failed");
+        return;
+    }
+    catch (error) {
+        if (Reflect.get(Object(error), "code") !== "ENOENT")
+            throw error;
+    }
+    const handle = await createPrivateFile(path);
+    try {
+        await handle.writeFile(text);
+    }
+    finally {
+        await handle.close();
+    }
+}
+export async function inspectAnalysisFiles(directory, output) {
+    const proposal = join(directory, `proposal-${output.cycleId}.txt`);
+    const analysis = join(directory, `analysis-${output.cycleId}.json`);
+    const marker = await boundedAnalysisFile(analysis, {
+        permissions: 0o600,
+    }).catch((error) => {
+        if (Reflect.get(Object(error), "code") === "ENOENT")
+            return undefined;
+        throw error;
+    });
+    if (marker === undefined)
+        return "absent";
+    if (marker !== output.analysis ||
+        (await boundedAnalysisFile(proposal, { permissions: 0o600 })) !==
+            output.proposal)
+        throw new Error("analysis-output-failed");
+    return "complete";
+}
+export async function saveAnalysisFiles(directory, output) {
+    if ((await inspectAnalysisFiles(directory, output)) === "complete")
+        return;
+    const proposal = join(directory, `proposal-${output.cycleId}.txt`);
+    const analysis = join(directory, `analysis-${output.cycleId}.json`);
+    await matchingPrivateFile(proposal, output.proposal);
+    await matchingPrivateFile(analysis, output.analysis);
+}

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

@@ -0,0 +1,12 @@
+import type { AdapterOutcome, DeliveryIntent } from "../broker/actor/delivery-intents.ts";
+import type { EffectDelivery } from "./delivery-router.ts";
+export interface ChatsWorkerSettings {
+    readonly runtimeDirectory: string;
+    readonly document: (digest: string) => Promise<string | undefined>;
+    readonly workflowId: (runId: string) => Promise<string | undefined>;
+}
+export interface ChatsWorker extends EffectDelivery {
+    readonly deliver: (intent: DeliveryIntent, signal: AbortSignal) => Promise<AdapterOutcome>;
+    readonly close: () => Promise<void>;
+}
+export declare function chatsWorker(settings: ChatsWorkerSettings): ChatsWorker;

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

@@ -0,0 +1,200 @@
+import { record } from "../protocol.js";
+import { validateAnalysis } from "../chats/analysis.js";
+import { analysisDocumentBytes, analysisEvidence, analysisModelInput, isAnalysisSnapshot, validAnalysisImportId, } from "../chats/analysis-input.js";
+import { analysisProposal } from "../chats/analysis-proposal.js";
+import { operationKey } from "./operation-journal.js";
+import { analysisDirectory, readAnalysisSnapshot, saveAnalysisFiles, inspectAnalysisFiles, } from "./chats-files.js";
+function completed(intent, result) {
+    return {
+        kind: "completed",
+        worker: "chats",
+        receipt: operationKey(intent.operationId),
+        result: JSON.stringify(result),
+    };
+}
+function refused(code, codes = [code]) {
+    return {
+        kind: "failed",
+        reason: code,
+        result: JSON.stringify({ kind: "blocked", codes }),
+    };
+}
+function bounded(text) {
+    if (Buffer.byteLength(text) > analysisDocumentBytes)
+        throw new Error("analysis-too-large");
+}
+function ownIntent(intent) {
+    return (intent.kind === "protected-effect" &&
+        intent.capability === "chats" &&
+        ["read-analysis", "save-analysis"].includes(intent.method ?? "") &&
+        intent.payload !== undefined &&
+        intent.leaseGeneration !== undefined);
+}
+async function payloadOf(settings, intent) {
+    if (!ownIntent(intent) || intent.payload === undefined)
+        throw new Error("unsupported-effect");
+    if ((await settings.workflowId(intent.runId)) !== "analyze-chats")
+        throw new Error("workflow-not-allowed");
+    const text = await settings.document(intent.payload);
+    if (text === undefined)
+        throw new Error("payload-not-available");
+    bounded(text);
+    const payload = record(JSON.parse(text));
+    if (payload === undefined)
+        throw new Error("analysis-input-refused");
+    const importId = payload["importId"];
+    if (typeof importId !== "string" || importId === "")
+        throw new Error("analysis-input-refused");
+    if (!validAnalysisImportId(importId))
+        throw new Error("invalid-import-id");
+    if (intent.target !== importId)
+        throw new Error("analysis-input-refused");
+    return payload;
+}
+async function read(settings, call) {
+    let directory;
+    try {
+        directory = await analysisDirectory(settings.runtimeDirectory, call.importId);
+    }
+    catch (error) {
+        if (Reflect.get(Object(error), "code") === "ENOENT")
+            throw new Error("redaction-required", { cause: error });
+        throw error;
+    }
+    const snapshot = await readAnalysisSnapshot(directory, call.importId);
+    bounded(JSON.stringify(snapshot));
+    bounded(JSON.stringify({ prompt: analysisModelInput(snapshot) }));
+    analysisEvidence(snapshot);
+    const result = { snapshot };
+    bounded(JSON.stringify(result));
+    return completed(call.intent, result);
+}
+function saveInput(payload) {
+    const snapshot = payload["snapshot"];
+    const cycleId = payload["cycleId"];
+    if (!isAnalysisSnapshot(snapshot) ||
+        snapshot.importId !== payload["importId"] ||
+        typeof cycleId !== "string" ||
+        !/^[A-Za-z0-9_-]{1,128}$/.test(cycleId) ||
+        typeof payload["reply"] !== "string")
+        throw new Error("analysis-input-refused");
+    let candidate;
+    try {
+        candidate = JSON.parse(payload["reply"]);
+    }
+    catch {
+        throw new Error("analysis-invalid-json");
+    }
+    return { snapshot, cycleId, candidate };
+}
+async function save(settings, call) {
+    const { snapshot, cycleId, candidate } = saveInput(call.payload);
+    const validation = validateAnalysis(candidate, analysisEvidence(snapshot));
+    if (!validation.accepted)
+        return refused(validation.codes[0] ?? "analysis-input-refused", validation.codes);
+    if (validation.result.openQuestion !== undefined)
+        return refused("analysis-input-refused");
+    try {
+        const directory = await analysisDirectory(settings.runtimeDirectory, snapshot.importId);
+        const output = {
+            cycleId,
+            analysis: JSON.stringify(validation.result) + "\n",
+            proposal: analysisProposal(validation.result),
+        };
+        if (call.mode === "reconcile" &&
+            (await inspectAnalysisFiles(directory, output)) === "absent")
+            return { kind: "absent" };
+        if (call.mode === "deliver")
+            await saveAnalysisFiles(directory, output);
+    }
+    catch {
+        throw new Error("analysis-output-failed");
+    }
+    return completed(call.intent, {
+        kind: "handoff_requested",
+        cycleId,
+        promotionId: `analysis:${snapshot.importId}:${cycleId}`,
+    });
+}
+const reasons = new Set([
+    "analysis-too-large",
+    "redaction-required",
+    "invalid-import-id",
+    "analysis-invalid-json",
+    "analysis-input-refused",
+    "analysis-output-failed",
+    "unsupported-effect",
+    "workflow-not-allowed",
+    "payload-not-available",
+]);
+async function delivered(settings, call) {
+    const { intent, mode } = call;
+    try {
+        if (call.signal?.aborted)
+            return { kind: "stopped" };
+        const payload = await payloadOf(settings, intent);
+        if (call.signal?.aborted)
+            return { kind: "stopped" };
+        if (intent.method === "read-analysis" && mode === "reconcile")
+            return { kind: "absent" };
+        if (intent.method === "read-analysis")
+            return await read(settings, {
+                intent,
+                importId: String(payload["importId"]),
+            });
+        return await save(settings, { intent, payload, mode });
+    }
+    catch (error) {
+        const message = String(Reflect.get(Object(error), "message"));
+        return refused(reasons.has(message) ? message : "analysis-input-refused");
+    }
+}
+export function chatsWorker(settings) {
+    if (process.platform !== "darwin") {
+        const unsupported = () => Promise.resolve(refused("platform-unsupported"));
+        return {
+            deliver: unsupported,
+            reconcile: unsupported,
+            stop: unsupported,
+            close: () => Promise.resolve(),
+        };
+    }
+    const active = new Map();
+    const lifecycle = { closed: false };
+    const deliver = (intent, signal) => {
+        if (lifecycle.closed || signal.aborted)
+            return Promise.resolve({ kind: "stopped" });
+        const key = operationKey(JSON.stringify([intent.runId, intent.operationId, intent.inputDigest]));
+        const known = active.get(key);
+        if (known !== undefined)
+            return known;
+        const pending = delivered(settings, {
+            intent,
+            mode: "deliver",
+            signal,
+        }).finally(() => active.delete(key));
+        active.set(key, pending);
+        return pending;
+    };
+    const stop = async (intent) => {
+        if (!ownIntent(intent))
+            return refused("unsupported-effect");
+        if ((await settings.workflowId(intent.runId)) !== "analyze-chats")
+            return refused("workflow-not-allowed");
+        const key = operationKey(JSON.stringify([intent.runId, intent.operationId, intent.inputDigest]));
+        const pending = active.get(key);
+        if (pending !== undefined)
+            return await pending;
+        const result = await delivered(settings, { intent, mode: "reconcile" });
+        return result.kind === "absent" ? { kind: "stopped" } : result;
+    };
+    return {
+        deliver,
+        reconcile: (intent) => delivered(settings, { intent, mode: "reconcile" }),
+        stop,
+        close: async () => {
+            lifecycle.closed = true;
+            await Promise.all(active.values());
+        },
+    };
+}

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

@@ -1,22 +1,31 @@
+import { type WorkerUsage } from "../worker-usage.ts";
 export type Worker = "claude" | "codex";
 export interface StreamResult {
+    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 interface TurnEnd {
+    readonly stopped?: boolean;
     readonly exitCode: number | null;
     readonly result: StreamResult | undefined;
 }
 export interface TurnStart {
+    readonly mode?: "analysis";
+    readonly analysisToken?: string;
     readonly worker?: Worker;
     readonly turnId?: string;
     readonly environment?: Readonly<Record<string, string>>;
     readonly command: readonly string[];
     readonly directory: string;
     readonly folder: string;
+    readonly activityFolder?: string;
     readonly prompt: string;
 }
 export interface RunningTurn {
@@ -24,5 +33,6 @@ export interface RunningTurn {
     readonly ended: Promise<TurnEnd>;
     readonly stop: (graceMilliseconds: number) => void;
 }
+export declare function capacityRefusal(result: StreamResult | undefined): boolean;
 export declare function streamResult(line: string): StreamResult | undefined;
 export declare function startTurn(start: TurnStart): RunningTurn;

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

@@ -2,6 +2,9 @@ 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 { commandModel } from "../token-prices.js";
+import { analysisCommand, analysisEnvironment } from "./analysis-launch.js";
 function parsed(line) {
     try {
         const value = JSON.parse(line);
@@ -17,6 +20,13 @@ function numberOf(value) {
 function textOf(value) {
     return typeof value === "string" ? value : null;
 }
+export function capacityRefusal(result) {
+    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) {
     if (!line.includes('"result"'))
         return undefined;
@@ -25,9 +35,17 @@ export function streamResult(line) {
     if (field("type") !== "result")
         return undefined;
     return {
+        ...(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: numberOf(field("total_cost_usd")),
+        costUsd: priceOf(field("total_cost_usd")),
+        usage: usageOf(field("usage")),
+        model: textOf(field("model")),
         sessionId: textOf(field("session_id")),
         turns: numberOf(field("num_turns")),
     };
@@ -38,6 +56,11 @@ function ended(stream) {
     });
 }
 function turnEnvironment(configuration, start) {
+    if (start.mode === "analysis")
+        return {
+            ...analysisEnvironment(start.folder),
+            CLAUDE_CODE_OAUTH_TOKEN: start.analysisToken,
+        };
     const excluded = new Set([
         "GH_TOKEN",
         "GITHUB_TOKEN",
@@ -56,7 +79,7 @@ function turnEnvironment(configuration, start) {
 }
 function spawnTurn(start) {
     const configuration = mkdtempSync(join(start.folder, "gh-config-"));
-    const [executable = "", ...fixed] = start.command;
+    const [executable = "", ...fixed] = start.mode === "analysis" ? analysisCommand() : start.command;
     try {
         const child = spawn(executable, fixed, {
             cwd: start.directory,
@@ -70,43 +93,101 @@ function spawnTurn(start) {
         throw error;
     }
 }
+function receivedLines(stream, lines) {
+    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 result = streamResult(line);
+        if (result !== undefined) {
+            const errorType = result.errorType ?? stream.errorType;
+            stream.result = {
+                ...result,
+                ...(errorType === null ? {} : { errorType }),
+            };
+        }
+    }
+}
+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) {
-    const output = createWriteStream(join(start.folder, "turn.jsonl"));
+    const output = activityOutput(start);
     const codex = start.worker === "codex" ? codexStream() : undefined;
-    const stream = { pending: "", result: undefined };
+    const stream = {
+        pending: "",
+        result: undefined,
+        model: null,
+        errorType: null,
+    };
+    const received = (lines) => {
+        receivedLines(stream, lines);
+    };
     const written = (lines) => {
         for (const line of lines)
-            output.write(`${line}\n`);
-        stream.result = lines.map(streamResult).findLast(Boolean) ?? stream.result;
+            output?.write(`${line}\n`);
+        received(lines);
     };
     stdout.setEncoding("utf8");
     stdout.on("data", (chunk) => {
         if (codex === undefined)
-            output.write(chunk);
+            output?.write(chunk);
         const lines = `${stream.pending}${chunk}`.split("\n");
         stream.pending = lines.pop() ?? "";
         if (codex !== undefined) {
             written(lines.flatMap(codex.line));
             return;
         }
-        stream.result = lines.map(streamResult).findLast(Boolean) ?? stream.result;
+        received(lines);
     });
     return async (exitCode) => {
         if (codex !== undefined) {
             written(codex.line(stream.pending));
             written([codex.result(exitCode)]);
         }
-        await ended(output);
-        return codex === undefined
-            ? (streamResult(stream.pending) ?? stream.result)
-            : stream.result;
+        if (output !== undefined)
+            await ended(output);
+        if (codex === 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),
+            };
+    };
+}
+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),
     };
 }
 export function startTurn(start) {
     const { child, configuration } = spawnTurn(start);
     const output = turnOutput(start, child.stdout);
-    const errors = createWriteStream(join(start.folder, "turn.stderr.log"));
-    child.stderr.pipe(errors);
+    if (start.mode === "analysis")
+        child.stderr.resume();
+    else
+        child.stderr.pipe(createWriteStream(join(start.folder, "turn.stderr.log")));
     child.stdin.on("error", () => undefined);
     child.stdin.end(start.prompt);
     const closed = new Promise((settle) => {
@@ -121,7 +202,7 @@ export function startTurn(start) {
             timers.forEach(clearTimeout);
             return {
                 exitCode,
-                result: await output(exitCode),
+                result: withoutAnalysisToken(start, await output(exitCode)),
             };
         })
             .finally(() => {

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

@@ -1,8 +1,11 @@
+import { type TokenPrices } from "../token-prices.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 {
+export interface ClaudeWorkerSettings extends RetrySettings {
+    readonly tokenPrices?: TokenPrices;
     readonly worker?: Worker;
     readonly profiles?: TurnProfiles;
     readonly workflowId?: (runId: string) => Promise<string | undefined>;