cloving 1.0.1 → 1.2.0

package/dist/src/cli.js

@@ -1,11 +1,48 @@
 #!/usr/bin/env node
-import { spawn } from "node:child_process";
+import { addAbortListener } from "node:events";
+import { execFile, spawn } from "node:child_process";
 import { delimiter, dirname, extname, join } from "node:path";
 import { main } from "./cli/main.js";
 import { clientCommand, runtimeDirectory } from "./cli/runtime-directory.js";
 import { commandUsage } from "./cli/usage.js";
 const [command, ...options] = process.argv.slice(2);
-function started(runtime) {
+const watchCommand = async (request) => {
+    const [command = "", ...argumentsList] = request.command;
+    const completed = Promise.withResolvers();
+    const stderr = { text: "" };
+    const execution = execFile(command, argumentsList, {
+        cwd: request.directory,
+        signal: request.signal,
+        killSignal: "SIGKILL",
+        maxBuffer: 1024 * 1024,
+        encoding: "utf8",
+    }, (error, stdout) => {
+        const code = error === null ? 0 : error.code;
+        completed.resolve({
+            stdout,
+            stderr: stderr.text,
+            status: typeof code === "number" ? code : null,
+            errorCode: typeof code === "string" ? code : null,
+        });
+    });
+    execution.stderr?.on("data", (chunk) => {
+        stderr.text += chunk.toString();
+    });
+    const closed = new Promise((resolve) => execution.once("close", () => {
+        resolve();
+    }));
+    const listener = addAbortListener(request.signal, () => {
+        execution.kill("SIGKILL");
+    });
+    try {
+        await closed;
+        return await completed.promise;
+    }
+    finally {
+        listener[Symbol.dispose]();
+    }
+};
+function started(runtime, argumentsList) {
     const program = join(import.meta.dirname, "..", "tools", `self-host${extname(import.meta.filename)}`);
     const located = [
         "--runtime",
@@ -15,7 +52,7 @@ function started(runtime) {
         "--client",
         clientCommand(process.env),
     ];
-    const child = spawn(process.execPath, [program, ...located, ...options], {
+    const child = spawn(process.execPath, [program, ...located, ...argumentsList], {
         stdio: "inherit",
         env: {
             ...process.env,
@@ -48,9 +85,10 @@ async function start() {
     }
     const runtime = runtimeDirectory(process.env);
     if (runtime !== undefined) {
-        let status = await started(runtime);
+        let status = await started(runtime, options);
+        const restarting = options.filter((option) => option !== "--reset-queue");
         while (status === 75)
-            status = await started(runtime);
+            status = await started(runtime, restarting);
         return status === 0 ? 0 : 1;
     }
     process.stderr.write("runtime-directory-unknown: Set CLOVING_RUNTIME_DIR to the runtime directory of the service.\n");
@@ -59,4 +97,8 @@ async function start() {
 if (command === "start")
     process.exitCode = await start();
 else
-    await main(process.argv.slice(2));
+    await main(process.argv.slice(2), {
+        repository: process.env["CLOVING_WATCH_REPOSITORY"],
+        githubCommand: process.env["CLOVING_GH_COMMAND"],
+        execute: watchCommand,
+    });

package/dist/src/daemon/analysis-launch.d.ts

@@ -0,0 +1,5 @@
+export { analysisInstruction } from "../chats/analysis-prompt.ts";
+export declare const analysisMethod = "run-turn:analyze-chats";
+export declare function analysisCommand(): readonly string[];
+export declare function analysisEnvironment(folder: string): NodeJS.ProcessEnv;
+export declare function analysisAvailable(folder: string): Promise<boolean>;

package/dist/src/daemon/analysis-launch.js

@@ -0,0 +1,81 @@
+import { execFile } from "node:child_process";
+import { join } from "node:path";
+import { promisify } from "node:util";
+import { analysisInstruction } from "../chats/analysis-prompt.js";
+export { analysisInstruction } from "../chats/analysis-prompt.js";
+export const analysisMethod = "run-turn:analyze-chats";
+const controls = [
+    "--safe-mode",
+    "--restricted",
+    "--strict-mcp-config",
+    "--disable-slash-commands",
+    "--no-chrome",
+    "--no-session-persistence",
+];
+export function analysisCommand() {
+    return [
+        "claude",
+        ...controls,
+        "--print",
+        "--output-format",
+        "stream-json",
+        "--verbose",
+        "--tools",
+        "",
+        "--disallowedTools",
+        "mcp__*",
+        "--mcp-config",
+        '{"mcpServers":{}}',
+        "--setting-sources",
+        "",
+        "--settings",
+        '{"disableAllHooks":true}',
+        "--permission-prompts",
+        "none",
+        "--max-turns",
+        "1",
+        "--max-budget-usd",
+        "5",
+        "--model",
+        "sonnet",
+        "--system-prompt",
+        analysisInstruction,
+    ];
+}
+export function analysisEnvironment(folder) {
+    return {
+        PATH: process.env["PATH"],
+        HOME: join(folder, "configuration"),
+        CLAUDE_CONFIG_DIR: join(folder, "configuration"),
+        TMPDIR: join(folder, "configuration"),
+        CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC: "1",
+    };
+}
+function supportedVersion(line) {
+    const match = /^2\.(0|[1-9]\d*)\.(0|[1-9]\d*) \(Claude Code\)$/.exec(line.trim());
+    if (match?.[1] === undefined || match[2] === undefined)
+        return false;
+    const minor = BigInt(match[1]);
+    return minor > 1n || (minor === 1n && BigInt(match[2]) >= 302n);
+}
+export async function analysisAvailable(folder) {
+    const probe = (flag) => promisify(execFile)("claude", [flag], {
+        cwd: folder,
+        env: analysisEnvironment(folder),
+        timeout: 5_000,
+        maxBuffer: 131_072,
+    });
+    try {
+        const version = await probe("--version");
+        if (!supportedVersion(version.stdout))
+            return false;
+        const help = await probe("--help");
+        const advertised = new Set(help.stdout.match(/--[a-zA-Z][a-zA-Z0-9-]*/g) ?? []);
+        return analysisCommand()
+            .filter((argument) => argument.startsWith("--"))
+            .every((flag) => advertised.has(flag));
+    }
+    catch {
+        return false;
+    }
+}

package/dist/src/daemon/analysis-token.d.ts

@@ -0,0 +1,6 @@
+export type AnalysisToken = {
+    readonly token: string;
+} | {
+    readonly error: string;
+};
+export declare function analysisToken(folder: string, signal?: AbortSignal): Promise<AnalysisToken>;

package/dist/src/daemon/analysis-token.js

@@ -0,0 +1,88 @@
+import { spawn } from "node:child_process";
+function failed(category) {
+    return { error: "analysis-token-command-" + category };
+}
+function commandOf(setting) {
+    try {
+        const parsed = JSON.parse(setting);
+        if (!Array.isArray(parsed) || parsed.length === 0)
+            return undefined;
+        const entries = parsed;
+        if (entries.every((entry) => typeof entry === "string" && entry.length > 0))
+            return entries;
+        return undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+function tokenOf(chunks) {
+    const token = Buffer.concat(chunks)
+        .toString("utf8")
+        .replace(/(?:\r\n|[\r\n])$/, "");
+    return /^[!-~]{1,512}$/.test(token) ? { token } : failed("output-invalid");
+}
+function captured(command, request) {
+    return new Promise((settle) => {
+        const [program = "", ...arguments_] = command;
+        const child = spawn(program, arguments_, {
+            cwd: request.folder,
+            shell: false,
+            stdio: ["ignore", "pipe", "pipe"],
+            signal: request.signal,
+            killSignal: "SIGKILL",
+        });
+        const chunks = [];
+        let bytes = 0;
+        let stopped = false;
+        const stop = (category) => {
+            stopped = true;
+            clearTimeout(timer);
+            child.kill("SIGKILL");
+            child.stdout.destroy();
+            child.stderr.destroy();
+            settle(failed(category));
+        };
+        const timer = setTimeout(() => {
+            stop("timeout");
+        }, 10_000);
+        const received = (chunk, output) => {
+            if (stopped)
+                return;
+            bytes += chunk.length;
+            if (bytes > 4_096) {
+                stop("output-too-large");
+                return;
+            }
+            output?.push(chunk);
+        };
+        child.stdout.on("data", (chunk) => {
+            received(chunk, chunks);
+        });
+        child.stderr.on("data", (chunk) => {
+            received(chunk);
+        });
+        child.once("error", () => {
+            stop("failed");
+        });
+        child.once("close", (code) => {
+            clearTimeout(timer);
+            if (!stopped)
+                settle(code === 0 ? tokenOf(chunks) : failed("failed"));
+        });
+    });
+}
+export async function analysisToken(folder, signal) {
+    const setting = process.env["CLOVING_ANALYSIS_TOKEN_COMMAND"];
+    if (setting === undefined)
+        return failed("unset");
+    const command = commandOf(setting);
+    if (command === undefined)
+        return failed("invalid");
+    try {
+        return await captured(command, { folder, signal });
+    }
+    catch {
+        return failed("failed");
+    }
+}

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

@@ -0,0 +1,20 @@
+import type { AdapterOutcome, DeliveryIntent } from "../broker/actor/delivery-intents.ts";
+import { type RetrySettings } from "./retrying-turn.ts";
+import { type WorkerReport } from "./operation-journal.ts";
+interface Settings extends RetrySettings {
+    readonly journal: string;
+    readonly document: (digest: string) => Promise<string | undefined>;
+    readonly report: (report: WorkerReport) => Promise<unknown>;
+    readonly stopMilliseconds?: number;
+}
+interface AnalysisWorker {
+    readonly deliver: (intent: DeliveryIntent, signal: AbortSignal) => Promise<AdapterOutcome | {
+        readonly receipt: string;
+        readonly worker: string;
+    }>;
+    readonly reconcile: (intent: DeliveryIntent, signal: AbortSignal) => Promise<AdapterOutcome>;
+    readonly stop: (intent: DeliveryIntent, signal: AbortSignal) => Promise<AdapterOutcome>;
+    readonly close: () => Promise<void>;
+}
+export declare function analysisWorker(settings: Settings): AnalysisWorker;
+export {};

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

@@ -0,0 +1,271 @@
+import { mkdir, rm } from "node:fs/promises";
+import { join } from "node:path";
+import { analysisFollowUp, analysisFollowUpPrompt, analysisLaunchBytes, } from "../chats/analysis-prompt.js";
+import { prepareAnalysisBatch } from "../chats/analysis-batches.js";
+import { isAnalysisSnapshot, analysisDocumentBytes, } from "../chats/analysis-input.js";
+import { record } from "../protocol.js";
+import { sumPrices } from "../worker-usage.js";
+import { startRetriedTurn } from "./retrying-turn.js";
+import { analysisAvailable, analysisMethod } from "./analysis-launch.js";
+import { analysisToken } from "./analysis-token.js";
+import { located, readRecord, writeRecord, replied, reportOf, interrupted, } from "./operation-journal.js";
+function own(intent) {
+    return (intent.kind === "protected-effect" &&
+        intent.capability === "claude" &&
+        intent.method === analysisMethod &&
+        intent.target !== undefined &&
+        intent.payload !== undefined &&
+        intent.leaseGeneration !== undefined);
+}
+function failed(reason) {
+    return { kind: "failed", reason };
+}
+function firstBatch(snapshot) {
+    const batch = prepareAnalysisBatch(snapshot, {
+        nextRecordIndex: 0,
+        completedBatchCount: 0,
+        previousResult: null,
+    });
+    if (batch.kind === "refused")
+        throw new Error(batch.code);
+    if (batch.nextRecordIndex !== batch.totalRecords)
+        throw new Error("analysis-too-large");
+    return batch;
+}
+function promptOf(text, target) {
+    if (text !== undefined && Buffer.byteLength(text) > analysisDocumentBytes)
+        throw new Error("analysis-too-large");
+    const payload = record(JSON.parse(text ?? "null"));
+    if (payload === undefined)
+        throw new Error("analysis-input-refused");
+    const snapshot = payload["snapshot"];
+    if (!isAnalysisSnapshot(snapshot) || snapshot.importId !== target)
+        throw new Error("analysis-input-refused");
+    const followUp = "followUp" in payload ? analysisFollowUp(payload["followUp"]) : undefined;
+    const data = batchInput(snapshot, payload);
+    const prompt = turnPrompt(data, followUp);
+    if (analysisLaunchBytes(prompt) > analysisDocumentBytes)
+        throw new Error("analysis-too-large");
+    return prompt;
+}
+function turnPrompt(data, followUp) {
+    const context = data.context === undefined ? {} : { context: data.context };
+    if (followUp === undefined)
+        return data.prompt;
+    return analysisFollowUpPrompt(data.snapshot, { ...followUp, ...context });
+}
+function batchInput(snapshot, payload) {
+    if (!("context" in payload)) {
+        const batch = firstBatch(snapshot);
+        return { snapshot: batch.snapshot, prompt: batch.prompt };
+    }
+    const context = record(payload["context"]);
+    if (context === undefined || Object.keys(context).length !== 3)
+        throw new Error("analysis-input-refused");
+    const position = [context["batchIndex"], context["firstRecordIndex"]];
+    if (!position.every((value) => typeof value === "number" && Number.isSafeInteger(value) && value >= 0) ||
+        Number(position[0]) > 3)
+        throw new Error("analysis-input-refused");
+    if (context["previousResult"] !== null &&
+        record(context["previousResult"]) === undefined)
+        throw new Error("analysis-input-refused");
+    return {
+        snapshot,
+        context,
+        prompt: JSON.stringify({ evidence: snapshot, context }),
+    };
+}
+async function cleaned(folder) {
+    await Promise.all(["configuration", "working"].map((name) => rm(join(folder, name), { recursive: true, force: true })));
+}
+async function privateRecord(folder, entry) {
+    await writeRecord(folder, { ...entry, permissions: "private" });
+}
+function outcome(end) {
+    const endedAt = new Date().toISOString();
+    if (end.stopped)
+        return { outcome: "stopped", endedAt };
+    const result = end.result;
+    if (result === undefined)
+        return { ...interrupted("analysis-turn-failed"), endedAt };
+    const fields = {
+        costUsd: result.costUsd,
+        usage: result.usage,
+        model: result.model,
+        ...(result.attempts === undefined ? {} : { attempts: result.attempts }),
+        sessionId: result.sessionId,
+        turns: result.turns,
+        estimatedCostUsd: sumPrices((result.attempts ?? []).map((attempt) => attempt.estimatedCostUsd)),
+    };
+    if (end.exitCode !== 0 || result.failed)
+        return {
+            outcome: "failed",
+            reason: "analysis-turn-failed",
+            endedAt,
+            result: JSON.stringify(fields),
+        };
+    if (Buffer.byteLength(result.text, "utf8") > 16_000)
+        return {
+            outcome: "failed",
+            reason: "analysis-reply-too-large",
+            endedAt,
+            result: JSON.stringify(fields),
+        };
+    return {
+        outcome: "completed",
+        endedAt,
+        result: JSON.stringify({ ...fields, reply: result.text }),
+    };
+}
+function running(processId) {
+    if (typeof processId !== "number")
+        return false;
+    try {
+        process.kill(processId, 0);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+async function reconcile(parts, intent) {
+    if (!own(intent))
+        return failed("unsupported-effect");
+    const { key, folder } = located(parts.settings.journal, intent.operationId);
+    const result = await readRecord(folder, "result.json");
+    if (result !== undefined) {
+        await cleaned(folder);
+        return replied({ receipt: key, worker: "claude" }, result);
+    }
+    if (parts.active.has(key))
+        return { kind: "accepted", receipt: key, worker: "claude" };
+    const started = await readRecord(folder, "started.json");
+    if (started === undefined)
+        return { kind: "absent" };
+    if (running(record(started)?.["processId"]))
+        return { kind: "unknown", evidence: key };
+    const ending = interrupted("analysis-turn-failed");
+    await privateRecord(folder, { name: "result.json", value: ending });
+    await cleaned(folder);
+    return replied({ receipt: key, worker: "claude" }, ending);
+}
+async function begun(parts, opening) {
+    const { intent, folder, key, directory, prompt } = opening;
+    const started = {
+        operationId: intent.operationId,
+        target: intent.target,
+        mode: "analysis",
+        startedAt: new Date().toISOString(),
+    };
+    const turn = await startRetriedTurn({
+        mode: "analysis",
+        analysisToken: opening.token,
+        command: [],
+        folder,
+        directory,
+        prompt,
+    }, { ...parts.settings, metadata: started });
+    const done = turn.ended
+        .then(async (end) => {
+        const result = outcome(end);
+        await privateRecord(folder, { name: "result.json", value: result });
+        await cleaned(folder);
+        await parts.settings.report(reportOf({ intent, worker: "claude", commandId: `analysis-turn:${key}` }, result));
+    })
+        .catch(() => undefined)
+        .finally(() => parts.active.delete(key));
+    parts.active.set(key, { turn, done });
+}
+function cancelled(parts, signal) {
+    return signal.aborted || parts.stopping.signal.aborted;
+}
+async function deliver(parts, call) {
+    const { intent, signal } = call;
+    if (!own(intent))
+        return failed("unsupported-effect");
+    const known = await reconcile(parts, intent);
+    if (known.kind !== "absent")
+        return known;
+    const { key, folder } = located(parts.settings.journal, intent.operationId);
+    const text = await parts.settings.document(intent.payload);
+    let prompt;
+    try {
+        prompt = promptOf(text, intent.target);
+    }
+    catch (error) {
+        return failed(error instanceof Error && error.message === "analysis-too-large"
+            ? "analysis-too-large"
+            : "analysis-input-refused");
+    }
+    await mkdir(join(folder, "configuration"), { recursive: true, mode: 0o700 });
+    if (!(await analysisAvailable(folder))) {
+        await cleaned(folder);
+        return failed("analysis-worker-unavailable");
+    }
+    if (cancelled(parts, signal)) {
+        await cleaned(folder);
+        return failed("analysis-turn-failed");
+    }
+    const credential = await analysisToken(folder, signal);
+    if (cancelled(parts, signal)) {
+        await cleaned(folder);
+        return failed("analysis-turn-failed");
+    }
+    if ("error" in credential) {
+        await cleaned(folder);
+        return {
+            ...failed("analysis-worker-unavailable"),
+            result: JSON.stringify({ error: credential.error }),
+        };
+    }
+    const directory = join(folder, "working");
+    await mkdir(directory, { mode: 0o700 });
+    await begun(parts, {
+        intent,
+        key,
+        folder,
+        directory,
+        prompt,
+        token: credential.token,
+    });
+    return { receipt: key, worker: "claude" };
+}
+async function halted(parts, active) {
+    active.turn.stop(parts.settings.stopMilliseconds ?? 2_000);
+    await active.done;
+}
+function delivered(parts, call) {
+    if (cancelled(parts, call.signal))
+        return Promise.resolve(failed("analysis-turn-failed"));
+    const key = call.intent.operationId;
+    const known = parts.preparing.get(key);
+    if (known !== undefined)
+        return known;
+    const signal = AbortSignal.any([call.signal, parts.stopping.signal]);
+    const pending = deliver(parts, { ...call, signal }).finally(() => parts.preparing.delete(key));
+    parts.preparing.set(key, pending);
+    return pending;
+}
+export function analysisWorker(settings) {
+    const parts = {
+        settings,
+        active: new Map(),
+        preparing: new Map(),
+        stopping: new AbortController(),
+    };
+    return {
+        deliver: (intent, signal) => delivered(parts, { intent, signal }),
+        reconcile: (intent) => reconcile(parts, intent),
+        stop: async (intent) => {
+            const active = parts.active.get(located(settings.journal, intent.operationId).key);
+            if (active !== undefined)
+                await halted(parts, active);
+            return reconcile(parts, intent);
+        },
+        close: async () => {
+            parts.stopping.abort();
+            await Promise.all(parts.preparing.values());
+            await Promise.all([...parts.active.values()].map((active) => halted(parts, active)));
+        },
+    };
+}

package/dist/src/daemon/chats-batch-binding.d.ts

@@ -0,0 +1,23 @@
+import { type AnalysisSnapshot } from "../chats/analysis-input.ts";
+import { type AnalysisCapture } from "./chats-capture.ts";
+interface AnalysisBatchBindingInput {
+    readonly runId: string;
+    readonly importId: string;
+    readonly snapshot: AnalysisSnapshot | undefined;
+    readonly batch?: unknown;
+}
+export declare function boundAnalysisBatch(directory: string, input: AnalysisBatchBindingInput): Promise<{
+    capture: AnalysisCapture;
+    snapshot: AnalysisSnapshot;
+    batch: {
+        batchIndex: number;
+        nextRecordIndex: number;
+    };
+    previous: import("../chats/analysis-checkpoint.ts").AnalysisCheckpoint;
+}>;
+export declare function previousCheckpoint(folder: string, input: {
+    readonly capture: AnalysisCapture;
+    readonly batchIndex: number;
+    readonly snapshot: AnalysisSnapshot;
+}): Promise<import("../chats/analysis-checkpoint.ts").AnalysisCheckpoint>;
+export {};

package/dist/src/daemon/chats-batch-binding.js

@@ -0,0 +1,99 @@
+import { join } from "node:path";
+import { record } from "../protocol.js";
+import { initialAnalysisCheckpoint, batchAnalysisCheckpoint, } from "../chats/analysis-checkpoint.js";
+import { analysisEvidence, } from "../chats/analysis-input.js";
+import { mergeAnalysisBatch } from "../chats/analysis-merge.js";
+import { prepareAnalysisBatch } from "../chats/analysis-batches.js";
+import { checkpointProposal } from "../chats/analysis-proposal.js";
+import { findAnalysisCapture, readCapturedAnalysisSnapshot, } from "./chats-capture.js";
+import { boundedAnalysisFile, inspectAnalysisFiles } from "./chats-files.js";
+export async function boundAnalysisBatch(directory, input) {
+    const capture = await findAnalysisCapture(directory, {
+        runId: input.runId,
+        importId: input.importId,
+    });
+    if (capture === undefined)
+        throw new Error("analysis-output-failed");
+    const snapshot = await readCapturedAnalysisSnapshot(directory, capture);
+    const binding = record(input.batch);
+    const batchIndex = binding?.["batchIndex"] ?? 0;
+    if (typeof batchIndex !== "number")
+        throw new Error("analysis-output-failed");
+    const previous = await previousCheckpoint(join(directory, `capture-${capture.key}`), {
+        capture,
+        batchIndex,
+        snapshot,
+    });
+    const prepared = prepareAnalysisBatch(snapshot, {
+        nextRecordIndex: previous.nextRecordIndex,
+        completedBatchCount: previous.completedBatchCount,
+        previousResult: previous.result,
+    });
+    if (prepared.kind === "refused")
+        throw new Error("analysis-output-failed");
+    if (input.snapshot !== undefined &&
+        JSON.stringify(input.batch === undefined ? snapshot : prepared.snapshot) !==
+            JSON.stringify(input.snapshot))
+        throw new Error("analysis-output-failed");
+    if (!matchingBatchBinding(input.batch, {
+        capturedDigest: capture.digest,
+        batchIndex,
+        nextRecordIndex: prepared.nextRecordIndex,
+        totalRecords: capture.totalRecords,
+    }))
+        throw new Error("analysis-output-failed");
+    return {
+        capture,
+        snapshot,
+        batch: { batchIndex, nextRecordIndex: prepared.nextRecordIndex },
+        previous,
+    };
+}
+function matchingBatchBinding(binding, expected) {
+    if (binding === undefined)
+        return expected.nextRecordIndex === expected.totalRecords;
+    const fields = record(binding);
+    return ["capturedDigest", "batchIndex", "nextRecordIndex"].every((name) => fields?.[name] === Reflect.get(expected, name));
+}
+export async function previousCheckpoint(folder, input) {
+    const { capture, batchIndex } = input;
+    if (!Number.isSafeInteger(batchIndex) || batchIndex < 0 || batchIndex > 3)
+        throw new Error("analysis-input-refused");
+    const initial = initialAnalysisCheckpoint(capture);
+    if (batchIndex === 0)
+        return initial;
+    const name = `analysis-checkpoint-${String(batchIndex)}.json`;
+    const text = await boundedAnalysisFile(join(folder, name), {
+        permissions: 0o600,
+    });
+    const checkpoint = restoreCheckpoint(text, input);
+    await inspectAnalysisFiles(folder, {
+        cycleId: `checkpoint-${String(batchIndex)}`,
+        analysis: JSON.stringify(checkpoint) + "\n",
+        proposal: checkpointProposal(checkpoint),
+    });
+    return checkpoint;
+}
+function restoreCheckpoint(text, input) {
+    const value = record(JSON.parse(text));
+    const result = record(value?.["result"]);
+    const nextRecordIndex = value?.["nextRecordIndex"];
+    if (result === undefined || typeof nextRecordIndex !== "number")
+        throw new Error("analysis-output-failed");
+    const merged = mergeAnalysisBatch({
+        previousResult: null,
+        candidate: Object.fromEntries(Object.entries(result).filter(([key]) => key !== "limitations")),
+        evidence: analysisEvidence(input.snapshot),
+        nextRecordIndex,
+    });
+    if (!merged.accepted)
+        throw new Error("analysis-output-failed");
+    const checkpoint = batchAnalysisCheckpoint(input.capture, {
+        batchIndex: input.batchIndex - 1,
+        nextRecordIndex,
+        result: merged.result,
+    });
+    if (text !== JSON.stringify(checkpoint) + "\n")
+        throw new Error("analysis-output-failed");
+    return checkpoint;
+}