cloving 1.2.0 → 1.4.0

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

@@ -1,271 +0,0 @@
-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

@@ -1,23 +0,0 @@
-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

@@ -1,99 +0,0 @@
-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;
-}

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

@@ -1,18 +0,0 @@
-import { type AnalysisSnapshot } from "../chats/analysis-input.ts";
-export interface AnalysisCapture {
-    readonly schemaVersion: 1;
-    readonly key: string;
-    readonly runId: string;
-    readonly importId: string;
-    readonly digest: string;
-    readonly totalRecords: number;
-}
-export declare function captureAnalysisSnapshot(directory: string, binding: {
-    readonly runId: string;
-    readonly importId: string;
-}): Promise<AnalysisCapture>;
-export declare function findAnalysisCapture(directory: string, binding: {
-    readonly runId: string;
-    readonly importId: string;
-}): Promise<AnalysisCapture | undefined>;
-export declare function readCapturedAnalysisSnapshot(directory: string, capture: AnalysisCapture): Promise<AnalysisSnapshot>;

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

@@ -1,194 +0,0 @@
-import { createHash } from "node:crypto";
-import { lstat, mkdtemp, readdir, rename, rm } from "node:fs/promises";
-import { join } from "node:path";
-import { record } from "../protocol.js";
-import { analysisEvidence, validAnalysisImportId, } from "../chats/analysis-input.js";
-import { validateDestination } from "../chats/destination.js";
-import { initialAnalysisCheckpoint } from "../chats/analysis-checkpoint.js";
-import { checkpointProposal } from "../chats/analysis-proposal.js";
-import { boundedAnalysisFile, matchingPrivateFile, readAnalysisCorpus, readAnalysisSnapshot, } from "./chats-files.js";
-export async function captureAnalysisSnapshot(directory, binding) {
-    const key = captureKey(binding);
-    const folder = join(directory, `capture-${key}`);
-    await validateDestination(directory);
-    await reclaimAbandonedCaptures(directory);
-    const existing = await findAnalysisCapture(directory, binding);
-    if (existing !== undefined)
-        return existing;
-    const temporary = await mkdtemp(join(directory, `.capture-${key}-${String(process.pid)}-`));
-    try {
-        const capture = await writeCapture(directory, {
-            ...binding,
-            folder: temporary,
-        });
-        try {
-            await rename(temporary, folder);
-        }
-        catch (error) {
-            if (!(error instanceof Error &&
-                "code" in error &&
-                (error.code === "EEXIST" || error.code === "ENOTEMPTY")))
-                throw error;
-            const published = await findAnalysisCapture(directory, binding);
-            if (published === undefined)
-                throw error;
-            return published;
-        }
-        return capture;
-    }
-    catch (error) {
-        if (missingRedaction(error))
-            throw new Error("redaction-required", { cause: error });
-        throw error;
-    }
-    finally {
-        await rm(temporary, { recursive: true, force: true });
-    }
-}
-function missingRedaction(error) {
-    if (!(error instanceof Error) ||
-        !("code" in error) ||
-        error.code !== "ENOENT" ||
-        !("path" in error) ||
-        typeof error.path !== "string")
-        return false;
-    return (error.path.endsWith("/redaction.json") ||
-        error.path.endsWith("/redacted.jsonl"));
-}
-async function reclaimAbandonedCaptures(directory) {
-    for (const entry of await readdir(directory, { withFileTypes: true })) {
-        if (entry.isDirectory() && absentCaptureOwner(entry.name))
-            await rm(join(directory, entry.name), { recursive: true, force: true });
-    }
-}
-function absentCaptureOwner(name) {
-    const owner = /^\.capture-[a-f0-9]{64}-([1-9][0-9]*)-[A-Za-z0-9]{6}$/.exec(name)?.[1];
-    if (owner === undefined)
-        return false;
-    const processId = Number(owner);
-    if (!Number.isSafeInteger(processId))
-        return false;
-    try {
-        process.kill(processId, 0);
-        return false;
-    }
-    catch (error) {
-        return error instanceof Error && "code" in error && error.code === "ESRCH";
-    }
-}
-export async function findAnalysisCapture(directory, binding) {
-    const folder = join(directory, `capture-${captureKey(binding)}`);
-    const stats = await lstat(folder).catch((error) => {
-        if (!(error instanceof Error && "code" in error && error.code === "ENOENT"))
-            throw error;
-        return undefined;
-    });
-    if (stats === undefined)
-        return undefined;
-    const capture = await capturedReference(folder, binding);
-    await readCapturedAnalysisSnapshot(directory, capture);
-    return capture;
-}
-async function writeCapture(directory, input) {
-    const snapshot = await copiedSnapshot(directory, {
-        folder: input.folder,
-        importId: input.importId,
-    });
-    const evidence = analysisEvidence(snapshot);
-    const capture = {
-        schemaVersion: 1,
-        key: captureKey(input),
-        runId: input.runId,
-        importId: input.importId,
-        digest: snapshotDigest(snapshot),
-        totalRecords: evidence.records.length,
-    };
-    await matchingPrivateFile(join(input.folder, "capture.json"), JSON.stringify(capture) + "\n");
-    await ensureInitialCheckpoint(input.folder, capture);
-    return capture;
-}
-export async function readCapturedAnalysisSnapshot(directory, capture) {
-    const key = captureKey(capture);
-    if (capture.key !== key)
-        throw new Error("analysis-input-refused");
-    const folder = join(directory, `capture-${key}`);
-    const stored = await capturedReference(folder, capture);
-    if (stored.digest !== capture.digest ||
-        stored.totalRecords !== capture.totalRecords ||
-        record(capture)?.["schemaVersion"] !== 1)
-        throw new Error("analysis-input-refused");
-    const snapshot = await readAnalysisSnapshot(folder, {
-        importId: capture.importId,
-        permissions: 0o600,
-    });
-    const evidence = analysisEvidence(snapshot);
-    if (snapshotDigest(snapshot) !== capture.digest ||
-        evidence.records.length !== capture.totalRecords)
-        throw new Error("analysis-input-refused");
-    await ensureInitialCheckpoint(folder, capture);
-    return snapshot;
-}
-async function ensureInitialCheckpoint(folder, capture) {
-    const checkpoint = initialAnalysisCheckpoint(capture);
-    for (const [name, expected] of [
-        ["checkpoint-0.json", JSON.stringify(checkpoint) + "\n"],
-        ["proposal-0.txt", checkpointProposal(checkpoint)],
-    ]) {
-        await matchingPrivateFile(join(folder, name), expected);
-    }
-}
-function captureKey(binding) {
-    if (!validAnalysisImportId(binding.importId) ||
-        !/^[A-Za-z0-9_-]{1,128}$/.test(binding.runId))
-        throw new Error("analysis-input-refused");
-    return createHash("sha256")
-        .update(JSON.stringify([binding.runId, binding.importId]))
-        .digest("hex");
-}
-function snapshotDigest(snapshot) {
-    return createHash("sha256").update(JSON.stringify(snapshot)).digest("hex");
-}
-async function copiedSnapshot(directory, capture) {
-    const redaction = await boundedAnalysisFile(join(directory, "redaction.json"));
-    await matchingPrivateFile(join(capture.folder, "redaction.json"), redaction);
-    const corpus = await readAnalysisCorpus(join(directory, "redacted.jsonl"), {
-        output: join(capture.folder, "redacted.jsonl"),
-    });
-    const structure = await boundedAnalysisFile(join(directory, "structure.json"));
-    await matchingPrivateFile(join(capture.folder, "structure.json"), structure);
-    return { importId: capture.importId, redaction, corpus, structure };
-}
-async function capturedReference(folder, binding) {
-    await validateDestination(folder);
-    if (((await lstat(folder)).mode & 0o777) !== 0o700)
-        throw new Error("analysis-output-failed");
-    const value = record(JSON.parse(await boundedAnalysisFile(join(folder, "capture.json"), {
-        permissions: 0o600,
-    })));
-    const identity = {
-        schemaVersion: 1,
-        key: captureKey(binding),
-        runId: binding.runId,
-        importId: binding.importId,
-    };
-    if (value === undefined ||
-        Object.keys(value).length !== 6 ||
-        !Object.entries(identity).every(([key, expected]) => value[key] === expected))
-        throw new Error("analysis-input-refused");
-    const digest = value["digest"];
-    const totalRecords = value["totalRecords"];
-    if (typeof digest !== "string" ||
-        !/^[a-f0-9]{64}$/.test(digest) ||
-        typeof totalRecords !== "number" ||
-        !Number.isSafeInteger(totalRecords) ||
-        totalRecords < 0)
-        throw new Error("analysis-input-refused");
-    return {
-        schemaVersion: 1,
-        key: identity.key,
-        runId: binding.runId,
-        importId: binding.importId,
-        digest,
-        totalRecords,
-    };
-}

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

@@ -1,41 +0,0 @@
-import { type AnalysisCheckpoint } from "../chats/analysis-checkpoint.ts";
-import { type AnalysisSnapshot } from "../chats/analysis-input.ts";
-import { type AnalysisBatchPreparation } from "../chats/analysis-batches.ts";
-import { type AnalysisCapture } from "./chats-capture.ts";
-import { type AnalysisDraftInput } from "./chats-files.ts";
-interface CheckpointInput {
-    readonly capture: AnalysisCapture;
-    readonly candidate: unknown;
-    readonly batchIndex: number;
-    readonly nextRecordIndex: number;
-    readonly mode: "deliver" | "reconcile";
-}
-interface FinalizeInput {
-    readonly runId: string;
-    readonly importId: string;
-    readonly cycleId: string;
-    readonly snapshot: AnalysisSnapshot | undefined;
-    readonly candidate: unknown;
-    readonly mode: "deliver" | "reconcile";
-    readonly batch?: unknown;
-    readonly draft?: AnalysisDraftInput;
-}
-export declare function finalizeAnalysis(directory: string, input: FinalizeInput): Promise<(Awaited<ReturnType<typeof saveAnalysisCheckpoint>> & {
-    readonly next?: AnalysisBatchPreparation | undefined;
-}) | {
-    readonly kind: "absent";
-}>;
-export declare function saveAnalysisCheckpoint(directory: string, input: CheckpointInput): Promise<{
-    kind: "committed" | "absent";
-    checkpoint: AnalysisCheckpoint & {
-        readonly result: import("../chats/analysis-contract.ts").AnalysisResult;
-    };
-    receipt: string;
-} | {
-    kind: "refused";
-    codes: readonly import("../chats/analysis-merge.ts").AnalysisMergeCode[];
-} | {
-    kind: "absent";
-    codes?: never;
-}>;
-export {};