cloving 1.1.0 → 1.2.0

package/dist/src/cli/watch-reads.d.ts

@@ -1,4 +1,7 @@
+import { type PrRepository } from "./watch-pr-identity.ts";
+import { type WorkflowStages } from "../workflow-declaration.ts";
 import { type Fields } from "../protocol.ts";
+import { type WorkflowRefusal } from "../workflow-refusals.ts";
 interface ReadStatus extends Fields {
     readonly runId: string;
     readonly latestSequence: number;
@@ -13,8 +16,11 @@ interface ReadRun {
     readonly events: readonly ReadEvent[];
 }
 export interface WatchRead {
+    readonly queue?: Fields;
     readonly service: string;
     readonly workflows: readonly string[];
+    readonly workflowRefusals: readonly WorkflowRefusal[];
+    readonly workflowStages?: WorkflowStages;
     readonly summaries: readonly ReadStatus[];
     readonly runs: readonly ReadRun[];
     readonly completionCandidates: readonly ReadRun[];
@@ -24,5 +30,5 @@ export interface WatchReader {
     readonly read: (now: string) => Promise<WatchRead>;
     readonly run: (runId: string) => Promise<WatchRead>;
 }
-export declare function watchReader(runtimeDirectory: string): WatchReader;
+export declare function watchReader(runtimeDirectory: string, repository?: PrRepository | null): WatchReader;
 export {};

package/dist/src/cli/watch-reads.js

@@ -1,9 +1,13 @@
+import { establishedIssue } from "./watch-pr-identity.js";
+import { isWorkflowStages, } from "../workflow-declaration.js";
 import { record } from "../protocol.js";
 import { send } from "./client.js";
 import { activeRun, recentRun } from "./watch-board.js";
+import { workflowRefusals, } from "../workflow-refusals.js";
 const unavailable = {
     service: "down",
     workflows: [],
+    workflowRefusals: [],
     summaries: [],
     runs: [],
     completionCandidates: [],
@@ -79,15 +83,15 @@ async function creationOf(reader, runId) {
     }
     return null;
 }
-function matchingCompletion(status, ticketIds) {
-    const ticketId = status["ticketId"];
+function matchingCompletion(status, context) {
+    const issue = establishedIssue(context.repository, status["issueIdentity"]);
     return (status.state === "completed" &&
         status["workflowId"] === "develop-issue" &&
         record(status["outcome"])?.["kind"] === "handoff_requested" &&
         record(status["outcome"])?.["ticketStatus"] !== "partial" &&
         record(status["outcome"])?.["issueUpdate"] !== "failed" &&
-        typeof ticketId === "string" &&
-        ticketIds.has(ticketId));
+        issue !== null &&
+        context.issues.has(JSON.stringify(issue)));
 }
 async function completionOf(reader, search) {
     const { runId, latestSequence } = search.summary;
@@ -106,12 +110,16 @@ async function completionOf(reader, search) {
                 state: status.state,
                 workflowId: status["workflowId"],
                 ticketId: status["ticketId"],
+                issueIdentity: status["issueIdentity"],
                 outcome: status["outcome"],
             },
         };
         reader.completions.set(runId, known);
     }
-    if (!matchingCompletion(known.status, search.ticketIds))
+    if (!matchingCompletion(known.status, {
+        issues: search.issues,
+        repository: reader.repository,
+    }))
         return null;
     const creation = known.creation === undefined
         ? await creationOf(reader, runId)
@@ -119,11 +127,20 @@ async function completionOf(reader, search) {
     reader.completions.set(runId, { ...known, creation });
     return { status: known.status, events: creation === null ? [] : [creation] };
 }
+function refreshedLinks(run, status) {
+    const links = Object.fromEntries(["parentRunId", "chainId", "childRunIds"]
+        .filter((name) => Object.hasOwn(status, name))
+        .map((name) => [name, status[name]]));
+    return {
+        ...run,
+        status: { ...run.status, ...links },
+    };
+}
 async function detailed(reader, summary) {
     const { runId, latestSequence: sequence } = summary;
     const known = reader.details.get(runId);
     if (known !== undefined && known.sequence === sequence)
-        return known.value;
+        return refreshedLinks(known.value, summary);
     const shown = await asked(reader, {
         operation: "status",
         parameters: { runId },
@@ -160,10 +177,10 @@ async function decisionsOf(reader) {
     });
     return list(questions["decisions"]);
 }
-function stoppedTicketIds(runs, now) {
+function stoppedIssues(runs, context) {
     const stopped = runs
         .map((run) => run.status)
-        .filter((status) => recentRun(status.latestAt, now) &&
+        .filter((status) => recentRun(status.latestAt, context.now) &&
         status["workflowId"] === "develop-issue" &&
         (["failed", "cancelled"].includes(status.state) ||
             (status.state === "completed" &&
@@ -171,16 +188,15 @@ function stoppedTicketIds(runs, now) {
         .toSorted((first, second) => Date.parse(second.latestAt ?? "") - Date.parse(first.latestAt ?? ""))
         .slice(0, 20);
     return new Set(stopped.flatMap((status) => {
-        const ticketId = status["ticketId"];
-        return status.state === "completed" &&
-            record(status["outcome"])?.["ticketStatus"] !== "partial" &&
-            record(status["outcome"])?.["issueUpdate"] !== "failed" &&
-            typeof ticketId === "string" &&
-            ticketId !== ""
-            ? [ticketId]
+        const issue = establishedIssue(context.repository, status["issueIdentity"]);
+        return status.state === "completed" && issue !== null
+            ? [JSON.stringify(issue)]
             : [];
     }));
 }
+function stageMetadata(value) {
+    return Object.fromEntries(Object.entries(record(value) ?? {}).flatMap(([workflowId, stages]) => isWorkflowStages(stages) ? [[workflowId, stages]] : []));
+}
 async function service(reader, now) {
     const status = await asked(reader, {
         operation: "status",
@@ -194,20 +210,25 @@ async function service(reader, now) {
     const current = summaries.filter((summary) => activeRun(summary.state) || recentRun(summary.latestAt, now));
     for (const summary of current)
         runs.push(await detailed(reader, summary));
-    const ticketIds = stoppedTicketIds(runs, now);
-    const older = ticketIds.size === 0
+    const issues = stoppedIssues(runs, { now, repository: reader.repository });
+    const older = issues.size === 0
         ? []
         : summaries.filter((summary) => !recentRun(summary.latestAt, now) &&
             summary["workflowId"] === "develop-issue" &&
             summary.state === "completed");
     for (const summary of older) {
-        const candidate = await completionOf(reader, { summary, ticketIds });
+        const candidate = await completionOf(reader, { summary, issues });
         if (candidate !== null)
             completionCandidates.push(candidate);
     }
     return {
         service: "up",
+        ...(record(status["queue"]) === undefined
+            ? {}
+            : { queue: record(status["queue"]) ?? {} }),
         workflows: list(status["workflows"]).filter((value) => typeof value === "string"),
+        workflowStages: stageMetadata(status["workflowStages"]),
+        workflowRefusals: workflowRefusals(status["workflowRefusals"]),
         summaries,
         runs,
         completionCandidates,
@@ -226,7 +247,7 @@ async function singleRun(reader, runId) {
     const status = statusOf(reply.result["run"]);
     const known = reader.details.get(runId);
     const value = known !== undefined && known.sequence === status.latestSequence
-        ? known.value
+        ? refreshedLinks(known.value, status)
         : await remember(reader, status);
     return {
         ...unavailable,
@@ -235,9 +256,10 @@ async function singleRun(reader, runId) {
         decisions: await decisionsOf(reader),
     };
 }
-export function watchReader(runtimeDirectory) {
+export function watchReader(runtimeDirectory, repository = null) {
     const reader = {
         runtimeDirectory,
+        repository,
         details: new Map(),
         completions: new Map(),
     };

package/dist/src/cli/watch-render.d.ts

@@ -1,6 +1,8 @@
 import type { CardForm } from "./watch-run-input.ts";
 import type { WorkerUsage } from "../worker-usage.ts";
-import type { PrObservation } from "./watch-pr-identity.ts";
+import type { PrIdentity, PrObservation } from "./watch-pr-identity.ts";
+import type { WorkflowRefusal } from "../workflow-refusals.ts";
+import type { Fields } from "../protocol.ts";
 export interface WatchItem {
     readonly kind: string;
     readonly text: string;
@@ -62,6 +64,9 @@ export interface WatchStep {
     readonly startedAt: string | null;
 }
 export interface WatchCard {
+    readonly parentRunId?: string | null;
+    readonly chainId?: string;
+    readonly childRunIds?: readonly string[];
     readonly estimatedCostUsd: number | null;
     readonly runId: string;
     readonly title: string | null;
@@ -92,8 +97,14 @@ export interface WatchWorkflow {
     readonly columns: readonly WatchColumn[];
 }
 export interface WatchRun {
+    readonly parentRunId?: string | null;
+    readonly chainId?: string;
+    readonly childRunIds?: readonly string[];
+    readonly mergeProof?: PrIdentity | null;
+    readonly issueIdentity?: PrIdentity | null;
     readonly issueUpdate?: "failed";
     readonly ticketStatus?: "complete" | "partial";
+    readonly promotionId?: string;
     readonly estimatedCostUsd: number | null;
     readonly ticketId: string | null;
     readonly title: string | null;
@@ -121,6 +132,8 @@ export interface WatchRun {
     readonly mergeCommit: string | null;
 }
 export interface WatchModel {
+    readonly queue?: Fields;
+    readonly workflowRefusals?: readonly WorkflowRefusal[];
     readonly cardForms?: readonly CardForm[];
     readonly workflows: readonly WatchWorkflow[];
     readonly startWorkflowId: string | null;

package/dist/src/cli/watch-render.js

@@ -75,7 +75,8 @@ export function completedDetail(run) {
     const update = run.issueUpdate === "failed"
         ? " Issue status update failed; check the GitHub operation."
         : "";
-    return `${verdicts[run.decision] ?? ""}The run completed${time} · cost ${cost}.${ticket}${update}`;
+    const promotion = run.promotionId === undefined ? "" : ` Promotion: ${run.promotionId}.`;
+    return `${verdicts[run.decision] ?? ""}The run completed${time} · cost ${cost}.${promotion}${ticket}${update}`;
 }
 export function phaseTime(phase, now) {
     if (phase.startedAt === null)

package/dist/src/cli/watch-server.js

@@ -13,6 +13,20 @@ import { watchStream } from "./watch-stream.js";
 export const defaultWatchPort = 3663;
 const forbidden = { status: 403, type: "text/plain", body: "refused" };
 const notFound = { status: 404, type: "text/plain", body: "not found" };
+const fontFiles = new Map([
+    "fira-code-latin-400-normal.woff2",
+    "fira-code-latin-500-normal.woff2",
+    "heebo-latin-500-normal.woff2",
+    "heebo-latin-700-normal.woff2",
+    "heebo-latin-800-normal.woff2",
+    "space-grotesk-latin-400-normal.woff2",
+    "space-grotesk-latin-500-normal.woff2",
+    "space-grotesk-latin-600-normal.woff2",
+    "space-grotesk-latin-700-normal.woff2",
+].map((name) => [
+    `/watch-fonts-v1/${name}`,
+    new URL(`assets/watch-fonts/${name}`, import.meta.resolve("#package")),
+]));
 const libraryFile = fileURLToPath(import.meta.resolve("preact"));
 function parsed(text) {
     try {
@@ -81,6 +95,7 @@ async function snapshot(watch, runId) {
     ]);
     const model = watchModel({
         ...read,
+        repository: watch.observer.repository ?? null,
         home: homedir(),
         client: watch.settings.client,
         updatedAt,
@@ -93,9 +108,25 @@ async function snapshot(watch, runId) {
         cardForms: watch.actions?.forms.filter((form) => shown.workflows.some((workflow) => workflow.workflowId === form.workflowId)) ?? [],
     };
 }
+async function fontReply(request) {
+    const fontFile = fontFiles.get(request.url ?? "");
+    if (fontFile === undefined)
+        return request.url?.startsWith("/watch-fonts-v1/") ? notFound : null;
+    if (request.method !== "GET")
+        return notFound;
+    return {
+        status: 200,
+        type: "font/woff2",
+        body: await readFile(fontFile),
+        cache: "public, max-age=31536000, immutable",
+    };
+}
 async function answered(watch, request) {
     if (!watchHost(request))
         return forbidden;
+    const font = await fontReply(request);
+    if (font !== null)
+        return font;
     const url = new URL(String(request.url), "http://localhost");
     if (request.method === "GET")
         return readReply(watch, url);
@@ -137,7 +168,7 @@ async function readReply(watch, url) {
 function replied(response, reply) {
     response.writeHead(reply.status, {
         "content-type": reply.type,
-        "cache-control": "no-store",
+        "cache-control": reply.cache ?? "no-store",
     });
     response.end(reply.body);
 }
@@ -161,7 +192,7 @@ export async function watchServer(settings) {
             : await watchActions(settings.runtimeDirectory),
         settings,
         observer,
-        reader: watchReader(settings.runtimeDirectory),
+        reader: watchReader(settings.runtimeDirectory, observer.repository ?? null),
         streams: new Map(),
         github: new Map(),
     };

package/dist/src/cli/watch-turn.js

@@ -32,7 +32,7 @@ export function Turn(props) {
     const groups = groupActivity(turn.activity);
     const working = turn.outcome === "in work";
     const cost = priceText(turn.costUsd, turn.estimatedCostUsd);
-    const heading = ["Claude turn", turn.outcome, turnTime(turn, now), cost];
+    const heading = ["Agent turn", turn.outcome, turnTime(turn, now), cost];
     const place = `Branch ${turn.branch} · work tree ${turn.worktree}`;
     const activity = groups.map((items, index) => component(Group, { items, open: working && index === groups.length - 1 }));
     return element("section", {

package/dist/src/cli/watch-view.d.ts

@@ -2,6 +2,9 @@ import type { CardControls } from "./watch-card-view.ts";
 import { type Shown } from "./watch-element.ts";
 import { type Copying, type WatchModel, type WatchPhase, type WatchRun } from "./watch-render.ts";
 import { type ColumnControls } from "./watch-board-view.ts";
+export declare function Queue(props: {
+    readonly model: WatchModel;
+}): Shown;
 interface Timed {
     readonly run: WatchRun;
     readonly now: string;
@@ -38,6 +41,7 @@ export declare function Header(props: {
 export interface PageProps {
     readonly cards?: CardControls;
     readonly model: WatchModel | null;
+    readonly observationNow?: string | undefined;
     readonly selected: string;
     readonly now: string;
     readonly stale: boolean;
@@ -45,6 +49,9 @@ export interface PageProps {
     readonly columns?: ColumnControls;
     readonly start?: StartControls;
 }
+export declare function RefusedWorkflows(props: {
+    readonly model: WatchModel;
+}): Shown;
 export declare function Page(props: PageProps): Shown;
 export declare function BoardPage(props: PageProps & {
     readonly model: WatchModel;

package/dist/src/cli/watch-view.js

@@ -1,10 +1,36 @@
 import { priceText, usageText, totalsSuffix } from "./usage-render.js";
 import { component, element } from "./watch-element.js";
 import { clockTime, completedDetail, counted, elapsed, phaseTime, runName, runTone, waitingDetail, } from "./watch-render.js";
-import { Board, WorkflowList, } from "./watch-board-view.js";
+import { Board, HandoffLinks, WorkflowList, } from "./watch-board-view.js";
 import { boardWorkflow, watchHash, watchLocation } from "./watch-navigation.js";
 import { Decision, Events, Turn } from "./watch-turn.js";
 import { StartRun } from "./watch-start-view.js";
+import { record } from "../protocol.js";
+export function Queue(props) {
+    const queue = props.model.queue;
+    if (queue === undefined)
+        return null;
+    const skipped = Array.isArray(queue["skipped"])
+        ? queue["skipped"]
+        : [];
+    return [
+        element("p", {
+            class: "meta",
+            children: `Queue: ${String(queue["busy"])} of ${String(queue["lanes"])} lanes busy`,
+        }),
+        ...skipped.map((value) => {
+            const ticket = record(value) ?? {};
+            const dependencies = ticket["dependencies"];
+            const needs = Array.isArray(dependencies)
+                ? `; needs ${dependencies.map(String).join(", ")}`
+                : "";
+            return element("p", {
+                class: "meta",
+                children: `Skipped ticket ${String(ticket["ticketId"])}: ${String(ticket["reason"])}${needs}`,
+            });
+        }),
+    ];
+}
 export const clove = {
     viewBox: "0.6625858545303345 0.6630800366401672 46.674827575683594 46.673831939697266",
     paths: [
@@ -98,7 +124,7 @@ export function PullRequest(props) {
         children: `#${String(pullRequest.number)}`,
     });
     const scores = reviews.map((review) => element("li", {
-        children: `Round ${String(review.round)} · Greptile ${String(review.score)}/5 · commit ${review.commit.slice(0, 7)}`,
+        children: `Round ${String(review.round)} · Review ${String(review.score)}/5 · commit ${review.commit.slice(0, 7)}`,
     }));
     const merge = mergeCommit === null
         ? null
@@ -124,7 +150,7 @@ export function Run(props) {
     const budget = run.spent === null || run.limit === null
         ? ""
         : ` · ${String(run.spent)} of ${String(run.limit)} effect units`;
-    const none = "No Claude turn for this run.";
+    const none = "No agent turn for this run.";
     const turns = run.turns.length === 0
         ? element("p", { class: "meta", children: none })
         : run.turns.map((item, index) => [
@@ -142,6 +168,7 @@ export function Run(props) {
     ];
     return [
         component(Banner, { run, now }),
+        component(HandoffLinks, { run }),
         element("section", {
             class: "run-usage",
             children: [
@@ -198,6 +225,22 @@ export function Header(props) {
         ],
     });
 }
+export function RefusedWorkflows(props) {
+    const refusals = props.model.workflowRefusals ?? [];
+    if (refusals.length === 0)
+        return null;
+    return element("section", {
+        class: "workflow-refusals",
+        children: [
+            element("h2", { children: "Refused workflows" }),
+            element("ul", {
+                children: refusals.map((entry) => element("li", {
+                    children: `${entry.scope} ${entry.label}: ${entry.codes.join(", ")}`,
+                })),
+            }),
+        ],
+    });
+}
 export function Page(props) {
     const { model, selected, now, stale, copying } = props;
     const head = component(Header, { model, stale });
@@ -215,6 +258,8 @@ export function Page(props) {
         return [
             head,
             down,
+            component(Queue, { model }),
+            component(RefusedWorkflows, { model }),
             element("a", {
                 class: "back",
                 href: watchHash({ workflowId: back, runId: null }),
@@ -235,7 +280,9 @@ export function BoardPage(props) {
         class: "board-page",
         children: [
             component(Header, { model, stale, start }),
+            component(Queue, { model }),
             down,
+            component(RefusedWorkflows, { model }),
             component(StartRun, {
                 workflows: model.workflows,
                 copying,
@@ -256,6 +303,7 @@ export function BoardPage(props) {
                         : component(Board, {
                             workflow,
                             now,
+                            observationNow: props.observationNow,
                             controls: props.columns,
                             cardForm: model.cardForms?.find((form) => form.workflowId === workflowId),
                             cards: props.cards,

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

@@ -1,9 +1,7 @@
 import type { AdapterOutcome, DeliveryIntent } from "../broker/actor/delivery-intents.ts";
-import { type TokenPrices } from "../token-prices.ts";
 import { type RetrySettings } from "./retrying-turn.ts";
 import { type WorkerReport } from "./operation-journal.ts";
 interface Settings extends RetrySettings {
-    readonly tokenPrices?: TokenPrices;
     readonly journal: string;
     readonly document: (digest: string) => Promise<string | undefined>;
     readonly report: (report: WorkerReport) => Promise<unknown>;

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

@@ -1,9 +1,10 @@
 import { mkdir, rm } from "node:fs/promises";
 import { join } from "node:path";
-import { analysisPrompt } from "../chats/analysis-prompt.js";
-import { isAnalysisSnapshot } from "../chats/analysis-input.js";
+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 { estimatedCostUsd, priceForModel, } from "../token-prices.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";
@@ -19,13 +20,60 @@ function own(intent) {
 function failed(reason) {
     return { kind: "failed", reason };
 }
-function snapshotOf(text) {
-    try {
-        return record(JSON.parse(text ?? "null"))?.["snapshot"];
-    }
-    catch {
-        return undefined;
+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 })));
@@ -33,7 +81,7 @@ async function cleaned(folder) {
 async function privateRecord(folder, entry) {
     await writeRecord(folder, { ...entry, permissions: "private" });
 }
-function outcome(end, prices) {
+function outcome(end) {
     const endedAt = new Date().toISOString();
     if (end.stopped)
         return { outcome: "stopped", endedAt };
@@ -44,12 +92,10 @@ function outcome(end, prices) {
         costUsd: result.costUsd,
         usage: result.usage,
         model: result.model,
+        ...(result.attempts === undefined ? {} : { attempts: result.attempts }),
         sessionId: result.sessionId,
         turns: result.turns,
-        estimatedCostUsd: estimatedCostUsd(result.usage, {
-            worker: "claude",
-            price: priceForModel(prices, result.model),
-        }),
+        estimatedCostUsd: sumPrices((result.attempts ?? []).map((attempt) => attempt.estimatedCostUsd)),
     };
     if (end.exitCode !== 0 || result.failed)
         return {
@@ -121,7 +167,7 @@ async function begun(parts, opening) {
     }, { ...parts.settings, metadata: started });
     const done = turn.ended
         .then(async (end) => {
-        const result = outcome(end, parts.settings.tokenPrices ?? {});
+        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));
@@ -142,9 +188,15 @@ async function deliver(parts, call) {
         return known;
     const { key, folder } = located(parts.settings.journal, intent.operationId);
     const text = await parts.settings.document(intent.payload);
-    const snapshot = snapshotOf(text);
-    if (!isAnalysisSnapshot(snapshot) || snapshot.importId !== intent.target)
-        return failed("analysis-input-refused");
+    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);
@@ -173,7 +225,7 @@ async function deliver(parts, call) {
         key,
         folder,
         directory,
-        prompt: analysisPrompt(snapshot),
+        prompt,
         token: credential.token,
     });
     return { receipt: key, worker: "claude" };

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 {};