@astrosheep/keiyaku 4.0.0 → 4.0.2

package/build/src/akuma/activity.js

@@ -1,139 +0,0 @@
-import { decodeAgentEvent } from "./provider.js";
-const SETTLED_LIMIT = 8;
-const INTENT_LIMIT = 2;
-function duration(startedAt, completedAt) {
-    const start = Date.parse(startedAt);
-    const end = Date.parse(completedAt);
-    if (!Number.isFinite(start) || !Number.isFinite(end) || end < start)
-        return undefined;
-    return end - start;
-}
-function toolKey(bodySequence, id) {
-    return `${bodySequence}:${id}`;
-}
-function narrationRow(fact, event) {
-    if (event.type === "assistant") {
-        return { kind: "said", sequence: fact.sequence, bodySequence: fact.bodySequence, at: fact.at, text: event.text };
-    }
-    if (event.type === "thought" || event.type === "note") {
-        return { kind: event.type, sequence: fact.sequence, bodySequence: fact.bodySequence, at: fact.at, text: event.text };
-    }
-    return null;
-}
-/** Fold the complete retained typed event window before any display budget. */
-export function foldActivity(facts) {
-    const rows = [];
-    const running = new Map();
-    for (const fact of facts) {
-        const event = decodeAgentEvent(fact.event);
-        const narration = narrationRow(fact, event);
-        if (narration !== null) {
-            rows.push({ settled: true, row: narration });
-            continue;
-        }
-        if (event.type !== "tool")
-            continue;
-        const key = toolKey(fact.bodySequence, event.id);
-        if (event.phase === "started") {
-            const index = rows.length;
-            rows.push({
-                settled: false,
-                row: {
-                    kind: "tool",
-                    sequence: fact.sequence,
-                    bodySequence: fact.bodySequence,
-                    at: fact.at,
-                    name: event.name,
-                    call: event.call,
-                    state: "running",
-                },
-            });
-            running.set(key, index);
-            continue;
-        }
-        const index = running.get(key);
-        if (index === undefined) {
-            rows.push({
-                settled: true,
-                row: {
-                    kind: "tool",
-                    sequence: fact.sequence,
-                    bodySequence: fact.bodySequence,
-                    at: fact.at,
-                    name: event.name,
-                    call: event.call,
-                    state: event.result,
-                },
-            });
-            continue;
-        }
-        const started = rows[index].row;
-        if (started.kind !== "tool")
-            throw new Error("Akuma activity tool fold lost its start row");
-        const elapsed = duration(started.at, fact.at);
-        rows[index] = {
-            settled: true,
-            row: {
-                kind: "tool",
-                sequence: started.sequence,
-                bodySequence: started.bodySequence,
-                at: started.at,
-                completedAt: fact.at,
-                ...(elapsed === undefined ? {} : { durationMs: elapsed }),
-                name: event.name,
-                call: event.call,
-                state: event.result,
-            },
-        };
-        running.delete(key);
-    }
-    return rows.map((entry) => entry.row);
-}
-function pendingTellFacts(tells) {
-    return tells
-        .filter((tell) => tell.state !== "consumed" && tell.state !== "voided-by-death")
-        .map((tell) => ({ id: tell.id, body: tell.body, recordedAt: tell.recordedAt }));
-}
-/** Apply the one bounded recent selection after folding semantic rows. */
-export function selectActivitySnapshot(facts, input = {}) {
-    const folded = foldActivity(facts);
-    const settled = folded.filter((row) => row.kind !== "tool" || row.state !== "running");
-    const selected = new Set(settled.slice(-SETTLED_LIMIT));
-    const intent = settled.filter((row) => row.kind === "said" || row.kind === "thought").slice(-INTENT_LIMIT);
-    for (const row of intent)
-        selected.add(row);
-    for (const row of folded) {
-        if (row.kind === "tool" && row.state === "running")
-            selected.add(row);
-    }
-    return {
-        rows: folded.filter((row) => selected.has(row)),
-        pendingTells: pendingTellFacts(input.pending ?? []),
-        omitted: settled.length - [...selected].filter((row) => row.kind !== "tool" || row.state !== "running").length,
-        lowestRetained: input.lowestRetained ?? (facts[0]?.sequence ?? null),
-        highest: input.highest ?? (facts.at(-1)?.sequence ?? null),
-    };
-}
-function visibleRows(facts, since, limit) {
-    const folded = foldActivity(facts);
-    return since ? folded.slice(0, limit) : folded.slice(-limit);
-}
-/** Project a cursor page; history never applies the recent snapshot pinning rules. */
-export function projectActivityHistory(slice, turns, input) {
-    const all = foldActivity(slice.rows);
-    const rows = visibleRows(slice.rows, input.since === true, input.limit);
-    const bodySequences = new Set(rows.map((row) => row.bodySequence));
-    return {
-        rows,
-        turns: turns.filter((turn) => bodySequences.has(turn.bodySequence)),
-        omitted: Math.max(0, all.length - rows.length),
-        hasEarlier: input.since !== true && all.length > rows.length,
-        hasLater: input.since === true && all.length > rows.length,
-        historyLost: input.since !== true
-            && all.length === rows.length
-            && slice.lowestRetained !== null
-            && slice.lowestRetained > 1,
-        lowestRetained: slice.lowestRetained,
-        highest: slice.highest,
-    };
-}

package/build/src/akuma/providers/claude.js

@@ -1,305 +0,0 @@
-import { AgentEventChannel, boundedEventText, boundedThoughtText, noteEvent, unknownEvent, } from "../provider.js";
-export const CLAUDE_MESSAGE_DISPOSITIONS = {
-    assistant: "assistant",
-    auth_status: "auth",
-    conversation_reset: "note",
-    prompt_suggestion: "drop",
-    rate_limit_event: "drop",
-    result: "terminal",
-    stream_event: "drop",
-    system: "system",
-    tool_progress: "drop",
-    tool_use_summary: "drop",
-    user: "tool-results",
-};
-export const CLAUDE_SYSTEM_DISPOSITIONS = {
-    api_retry: "note",
-    background_tasks_changed: "note",
-    commands_changed: "drop",
-    compact_boundary: "drop",
-    control_request_progress: "control-progress",
-    elicitation_complete: "drop",
-    files_persisted: "note",
-    hook_progress: "drop",
-    hook_response: "drop",
-    hook_started: "note",
-    informational: "note",
-    init: "drop",
-    local_command_output: "drop",
-    memory_recall: "drop",
-    mirror_error: "note",
-    model_refusal_fallback: "note",
-    model_refusal_no_fallback: "note",
-    notification: "note",
-    permission_denied: "note",
-    plugin_install: "note",
-    session_state_changed: "drop",
-    status: "note",
-    task_notification: "note",
-    task_progress: "note",
-    task_started: "note",
-    task_updated: "note",
-    thinking_tokens: "drop",
-    worker_shutting_down: "note",
-};
-function assistantText(message) {
-    if (message.type !== "assistant" || message.aborted === true || message.error !== undefined)
-        return null;
-    const text = message.message.content
-        .filter((block) => block.type === "text")
-        .map((block) => block.text)
-        .join("");
-    return text.length === 0 ? null : text;
-}
-function object(value) {
-    return value !== null && typeof value === "object" && !Array.isArray(value)
-        ? value
-        : undefined;
-}
-function nonblank(value) {
-    return typeof value === "string" && value.trim().length > 0 ? value.trim() : undefined;
-}
-function number(value) {
-    return typeof value === "number" && Number.isFinite(value) ? value : undefined;
-}
-const CLAUDE_SYSTEM_NOTES = {
-    api_retry: (message) => {
-        const attempt = number(message.attempt);
-        const maximum = number(message.max_retries);
-        return attempt === undefined || maximum === undefined
-            ? "Retrying request"
-            : `Retrying request ${attempt}/${maximum}`;
-    },
-    background_tasks_changed: (message) => `Background tasks: ${Array.isArray(message.tasks) ? message.tasks.length : 0}`,
-    files_persisted: (message) => {
-        const files = Array.isArray(message.files) ? message.files.length : 0;
-        const failed = Array.isArray(message.failed) ? message.failed.length : 0;
-        return failed === 0 ? `Persisted ${files} files` : `Persisted ${files} files; ${failed} failed`;
-    },
-    hook_started: (message) => `Hook ${nonblank(message.hook_name) ?? "unknown"} started`,
-    informational: (message) => nonblank(message.content) ?? "Informational notice",
-    mirror_error: (message) => `Transcript mirror warning: ${nonblank(message.error) ?? nonblank(message.message) ?? "unknown error"}`,
-    model_refusal_fallback: () => "Model refusal; using fallback",
-    model_refusal_no_fallback: () => "Model refusal; no fallback available",
-    notification: (message) => nonblank(message.message) ?? nonblank(message.content) ?? "Notification",
-    permission_denied: (message) => `Permission refused${nonblank(message.message) === undefined ? "" : `: ${nonblank(message.message)}`}`,
-    plugin_install: (message) => `Plugin install ${nonblank(message.status) ?? "updated"}${nonblank(message.name) === undefined ? "" : `: ${nonblank(message.name)}`}`,
-    status: (message) => `Status: ${nonblank(message.status) ?? "idle"}${nonblank(message.error) === undefined ? "" : ` (${nonblank(message.error)})`}`,
-    task_notification: (message) => `Task ${nonblank(message.task_id) ?? "unknown"} ${nonblank(message.status) ?? "updated"}`,
-    task_progress: (message) => nonblank(message.description) ?? `Task ${nonblank(message.task_id) ?? "unknown"} progressed`,
-    task_started: (message) => nonblank(message.description) ?? `Task ${nonblank(message.task_id) ?? "unknown"} started`,
-    task_updated: (message) => `Task ${nonblank(message.task_id) ?? "unknown"} updated`,
-    worker_shutting_down: (message) => `Worker stopping: ${nonblank(message.reason) ?? "unknown reason"}`,
-};
-function toolCall(name, input) {
-    const value = object(input) ?? {};
-    const command = nonblank(value.command);
-    if (command !== undefined)
-        return { kind: "run", command: boundedEventText(command) };
-    const path = nonblank(value.file_path) ?? nonblank(value.path);
-    if (/^(?:read|view)/iu.test(name) && path !== undefined)
-        return { kind: "read", path: boundedEventText(path) };
-    const query = nonblank(value.query) ?? nonblank(value.pattern);
-    if (/search|grep|glob/iu.test(name) && query !== undefined)
-        return { kind: "search", query: boundedEventText(query) };
-    if (/write/iu.test(name) && path !== undefined) {
-        return { kind: "fileChange", changes: [{ op: "add", path: boundedEventText(path) }] };
-    }
-    if (/edit|notebook/iu.test(name) && path !== undefined) {
-        return { kind: "fileChange", changes: [{ op: "update", path: boundedEventText(path) }] };
-    }
-    return { kind: "other", display: boundedEventText(name) };
-}
-function assistantEvents(message, events, state) {
-    if (message.aborted === true)
-        return;
-    if (message.error !== undefined) {
-        events.emit(noteEvent(`Assistant error: ${message.error}`));
-        return;
-    }
-    const text = assistantText(message);
-    if (text !== null)
-        events.emit({ type: "assistant", text: boundedEventText(text) });
-    for (const block of message.message.content) {
-        const value = object(block);
-        if (value?.type === "thinking" && typeof value.thinking === "string" && value.thinking.trim().length > 0) {
-            events.emit({ type: "thought", text: boundedThoughtText(value.thinking) });
-            continue;
-        }
-        if (block.type !== "tool_use")
-            continue;
-        const call = toolCall(block.name, block.input);
-        state.tools.set(block.id, { name: block.name, call });
-        events.emit({ type: "tool", phase: "started", id: block.id, name: block.name, call });
-    }
-}
-function toolResultEvents(message, events, state) {
-    const content = object(message.message)?.content;
-    if (!Array.isArray(content))
-        return;
-    for (const block of content) {
-        const value = object(block);
-        if (value?.type !== "tool_result")
-            continue;
-        const id = nonblank(value.tool_use_id);
-        if (id === undefined)
-            continue;
-        const observed = state.tools.get(id);
-        if (observed === undefined)
-            continue;
-        state.tools.delete(id);
-        events.emit({
-            type: "tool",
-            phase: "completed",
-            id,
-            name: observed.name,
-            call: observed.call,
-            result: { status: value.is_error === true ? "error" : "ok" },
-        });
-    }
-}
-function systemNote(message, subtype) {
-    const note = CLAUDE_SYSTEM_NOTES[subtype];
-    return note?.(message) ?? subtype;
-}
-function emitClaudeMessage(message, events, state) {
-    const value = object(message);
-    const kind = nonblank(value?.type) ?? "unknown";
-    if (!Object.hasOwn(CLAUDE_MESSAGE_DISPOSITIONS, kind)) {
-        events.emit(unknownEvent(kind));
-        return;
-    }
-    const disposition = CLAUDE_MESSAGE_DISPOSITIONS[kind];
-    if (disposition === "assistant") {
-        assistantEvents(message, events, state);
-        return;
-    }
-    if (disposition === "tool-results") {
-        toolResultEvents(message, events, state);
-        return;
-    }
-    if (disposition === "auth") {
-        const error = nonblank(value?.error);
-        if (error !== undefined)
-            events.emit(noteEvent(`Authentication warning: ${error}`));
-        return;
-    }
-    if (disposition === "note") {
-        events.emit(noteEvent("Conversation reset"));
-        return;
-    }
-    if (disposition !== "system")
-        return;
-    const subtype = nonblank(value?.subtype) ?? "unknown";
-    if (!Object.hasOwn(CLAUDE_SYSTEM_DISPOSITIONS, subtype)) {
-        events.emit(unknownEvent(subtype));
-        return;
-    }
-    const systemDisposition = CLAUDE_SYSTEM_DISPOSITIONS[subtype];
-    if (systemDisposition === "drop")
-        return;
-    if (systemDisposition === "control-progress" && value?.status !== "api_retry")
-        return;
-    events.emit(noteEvent(systemNote(value ?? {}, subtype)));
-}
-function admitClaudeOptions(options) {
-    if (options.network !== undefined) {
-        return { kind: "refused", diagnostic: "Claude provider does not support the Archetype network option" };
-    }
-    return { kind: "admitted", options: Object.freeze({ ...options }) };
-}
-function permissionMode(access) {
-    if (access === "read")
-        return "plan";
-    if (access === "write")
-        return "acceptEdits";
-    return "bypassPermissions";
-}
-async function forkClaude(load, execution, input) {
-    if (execution.env !== undefined) {
-        throw new Error("Claude fork cannot apply the frozen provider environment");
-    }
-    const sdk = await load();
-    if (sdk.forkSession === undefined)
-        throw new Error("Claude SDK does not expose forkSession");
-    const forked = await sdk.forkSession(input.session.sessionId, { dir: input.cwd, upToMessageId: input.at });
-    if (forked.sessionId.trim().length === 0)
-        throw new Error("Claude fork returned an empty child session id");
-    if (forked.sessionId === input.session.sessionId)
-        throw new Error("Claude fork reused the source session id");
-    return { session: { sessionId: forked.sessionId } };
-}
-export function createClaudeProvider(load, execution = {}) {
-    return {
-        confinement: () => ({ kind: "unconfined" }),
-        admitOptions: admitClaudeOptions,
-        fork: (input) => forkClaude(load, execution, input),
-        async start(input) {
-            const sdk = await load();
-            const events = new AgentEventChannel();
-            const abortController = new AbortController();
-            const providerOptions = input.options;
-            const access = permissionMode(providerOptions.access);
-            const options = {
-                cwd: input.cwd,
-                abortController,
-                ...(execution.executable === undefined ? {} : { pathToClaudeCodeExecutable: execution.executable }),
-                ...(execution.env === undefined ? {} : { env: { ...process.env, ...execution.env } }),
-                permissionMode: access,
-                ...(access === "bypassPermissions" ? { allowDangerouslySkipPermissions: true } : {}),
-                settingSources: ["user", "project", "local"],
-                ...(providerOptions.model === undefined ? {} : { model: providerOptions.model }),
-                ...(providerOptions.effort === undefined ? {} : { effort: providerOptions.effort }),
-                ...(providerOptions.systemPrompt === undefined || providerOptions.systemPrompt.length === 0 ? {} : {
-                    systemPrompt: { type: "preset", preset: "claude_code", append: providerOptions.systemPrompt },
-                }),
-                ...(input.session === undefined ? {} : { resume: input.session.sessionId }),
-            };
-            const query = sdk.query({ prompt: input.prompt, options });
-            const observation = { tools: new Map() };
-            let admitted = false;
-            let settle;
-            const completion = new Promise((resolve) => { settle = resolve; });
-            void (async () => {
-                let terminal = null;
-                let historyId;
-                try {
-                    for await (const message of query) {
-                        if (!admitted && "session_id" in message && typeof message.session_id === "string") {
-                            admitted = true;
-                            events.emit({ type: "session", coordinate: { sessionId: message.session_id } });
-                        }
-                        emitClaudeMessage(message, events, observation);
-                        if (message.type === "assistant" && message.parent_tool_use_id === null
-                            && typeof message.uuid === "string" && message.uuid.length > 0) {
-                            historyId = message.uuid;
-                        }
-                        if (message.type === "result")
-                            terminal = message.subtype === "success"
-                                ? historyId === undefined
-                                    ? { kind: "failed", diagnostic: "Claude query succeeded without an assistant history id" }
-                                    : { kind: "answered", answer: message.result, historyId }
-                                : { kind: "failed", diagnostic: message.errors.join("; ") || message.subtype };
-                    }
-                    settle(terminal ?? { kind: "failed", diagnostic: "Claude query ended without a result" });
-                }
-                catch (error) {
-                    settle({ kind: "failed", diagnostic: error instanceof Error ? error.message : String(error) });
-                }
-                finally {
-                    events.end();
-                }
-            })();
-            return {
-                events,
-                completion,
-                async abort() {
-                    abortController.abort();
-                    query.close();
-                    await completion;
-                },
-            };
-        },
-    };
-}
-export const claudeProvider = createClaudeProvider(async () => await import("@anthropic-ai/claude-agent-sdk"));

package/build/src/context-root.d.ts

@@ -1,4 +0,0 @@
-export declare function resolveContextRoot(input: Readonly<{
-    from: string;
-    marker: string;
-}>): string;

package/build/src/context-root.js

@@ -1,15 +0,0 @@
-import { existsSync, realpathSync, statSync } from "node:fs";
-import { dirname, parse, resolve } from "node:path";
-export function resolveContextRoot(input) {
-    const origin = realpathSync(resolve(input.from));
-    for (let candidate = origin;; candidate = dirname(candidate)) {
-        const marker = resolve(candidate, input.marker);
-        if (existsSync(marker)) {
-            if (!statSync(marker).isDirectory())
-                throw new Error(`context marker is not a directory: ${marker}`);
-            return candidate;
-        }
-        if (candidate === parse(candidate).root)
-            return origin;
-    }
-}

package/build/src/git/delivery.d.ts

@@ -1,20 +0,0 @@
-import type { Preparation } from "../core/decide.js";
-import type { ChangeId, ContractCoordinates, ContractId, DeliverData } from "../core/facts/types.js";
-import { type GitRepository } from "./repository.js";
-export type DeliveryPreparationRefusal = Readonly<{
-    kind: "target-missing" | "candidate-not-based-on-target" | "worktree-missing";
-    contractId: ContractId;
-}>;
-export type ReviewPreparationRefusal = Readonly<{
-    kind: "worktree-missing";
-    contractId: ContractId;
-}>;
-export type DeliveryPreparationCoordinates = Readonly<{
-    contractId: ContractId;
-    coordinates: ContractCoordinates;
-}>;
-export declare function prepareReview(repository: GitRepository, input: DeliveryPreparationCoordinates): Preparation<ChangeId, ReviewPreparationRefusal>;
-export declare function prepareDelivery(repository: GitRepository, stage: DeliveryPreparationCoordinates, input: Readonly<{
-    title: string;
-    message?: string;
-}>): Preparation<DeliverData, DeliveryPreparationRefusal>;

package/build/src/git/delivery.js

@@ -1,109 +0,0 @@
-import { existsSync, mkdtempSync, rmSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import { mintChangeId, mintSnapshotId, gitObjectIdForSnapshot, gitObjectId } from "./identity.js";
-import { readRef, registeredWorktreePaths, runGit, runGitWithEnvironment } from "./repository.js";
-import { deliveryWorktreePath } from "./reconcile.js";
-function workspaceExists(repository, workspace, path) {
-    return workspace === "here"
-        || (existsSync(path) && registeredWorktreePaths(repository).includes(path));
-}
-function withPrivateGitIndex(action) {
-    const directory = mkdtempSync(join(tmpdir(), "keiyaku-v4-index-"));
-    const index = join(directory, "index");
-    try {
-        return action({ GIT_INDEX_FILE: index });
-    }
-    finally {
-        rmSync(directory, { recursive: true, force: true });
-    }
-}
-function workspaceFor(repository, id, workspace) {
-    return workspace === "worktree" ? deliveryWorktreePath(repository, id) : repository.effectiveCwd;
-}
-function stablePatchId(repository, predecessor, tree) {
-    const diff = runGit(repository, ["diff", "--binary", gitObjectIdForSnapshot(predecessor), tree]);
-    const output = runGit(repository, ["patch-id", "--stable"], diff).toString("utf8").trim();
-    const separator = output.indexOf(" ");
-    const identity = output.length === 0
-        ? runGit(repository, ["hash-object", "-t", "blob", "--stdin"], diff).toString("utf8").trim()
-        : separator < 0 ? output : output.slice(0, separator);
-    return mintChangeId(identity);
-}
-function workspaceTree(repository, workspace) {
-    const identities = runGit(repository, ["-C", workspace, "rev-parse", "HEAD", "HEAD^{tree}"])
-        .toString("utf8")
-        .split("\n");
-    if (identities.length !== 3 || identities[0] === undefined || identities[1] === undefined || identities[2] !== "") {
-        throw new Error("workspace HEAD/tree resolution did not return exactly two object IDs");
-    }
-    const head = mintSnapshotId(identities[0]);
-    const tree = gitObjectId(identities[1], "workspace tree");
-    const status = runGit(repository, ["-C", workspace, "status", "--porcelain=v1", "--untracked-files=all"]).toString("utf8");
-    const dirty = status.length > 0;
-    if (!dirty)
-        return { tree, head, dirty };
-    return withPrivateGitIndex((environment) => {
-        runGitWithEnvironment(repository, ["-C", workspace, "read-tree", "HEAD"], undefined, environment);
-        runGitWithEnvironment(repository, ["-C", workspace, "add", "--all"], undefined, environment);
-        const tree = gitObjectId(runGitWithEnvironment(repository, ["-C", workspace, "write-tree"], undefined, environment).toString("utf8").trim(), "workspace tree");
-        return { tree, head, dirty };
-    });
-}
-function materializeCandidate(input) {
-    const subject = input.message ?? `${input.contractId}: ${input.title}`;
-    const message = `${subject}\n\nKeiyaku-Contract: ${input.contractId}\n`;
-    const commit = runGitWithEnvironment(input.repository, ["-C", input.workspace, "commit-tree", input.tree, "-p", gitObjectIdForSnapshot(input.head)], message, {
-        GIT_AUTHOR_NAME: "Keiyaku",
-        GIT_AUTHOR_EMAIL: "keiyaku@localhost",
-        GIT_COMMITTER_NAME: "Keiyaku",
-        GIT_COMMITTER_EMAIL: "keiyaku@localhost",
-        GIT_AUTHOR_DATE: "Thu, 01 Jan 1970 00:00:00 +0000",
-        GIT_COMMITTER_DATE: "Thu, 01 Jan 1970 00:00:00 +0000",
-    }).toString("utf8").trim();
-    return mintSnapshotId(commit);
-}
-export function prepareReview(repository, input) {
-    const workspace = workspaceFor(repository, input.contractId, input.coordinates.workspace);
-    if (!workspaceExists(repository, input.coordinates.workspace, workspace)) {
-        return { kind: "refused", refusal: { kind: "worktree-missing", contractId: input.contractId } };
-    }
-    const tree = workspaceTree(repository, workspace);
-    return { kind: "prepared", data: stablePatchId(repository, input.coordinates.start, tree.tree) };
-}
-export function prepareDelivery(repository, stage, input) {
-    const id = stage.contractId;
-    const coordinates = stage.coordinates;
-    const observedTarget = coordinates.target === undefined ? null : readRef(repository, coordinates.target);
-    if (coordinates.target !== undefined && observedTarget === null) {
-        return { kind: "refused", refusal: { kind: "target-missing", contractId: id } };
-    }
-    const predecessor = observedTarget === null ? coordinates.start : mintSnapshotId(observedTarget);
-    const workspace = workspaceFor(repository, id, coordinates.workspace);
-    if (!workspaceExists(repository, coordinates.workspace, workspace)) {
-        return { kind: "refused", refusal: { kind: "worktree-missing", contractId: id } };
-    }
-    const content = workspaceTree(repository, workspace);
-    const candidate = content.dirty
-        ? materializeCandidate({ repository, contractId: id, workspace, ...input, tree: content.tree, head: content.head })
-        : content.head;
-    if (coordinates.target !== undefined) {
-        try {
-            runGit(repository, ["merge-base", "--is-ancestor", gitObjectIdForSnapshot(predecessor), gitObjectIdForSnapshot(candidate)]);
-        }
-        catch (error) {
-            const status = error.status;
-            if (status === 1)
-                return { kind: "refused", refusal: { kind: "candidate-not-based-on-target", contractId: id } };
-            throw error;
-        }
-    }
-    return {
-        kind: "prepared",
-        data: {
-            expectedPredecessor: predecessor,
-            candidate,
-            deliveryPatchId: stablePatchId(repository, predecessor, content.tree),
-        },
-    };
-}

package/build/src/git/verification.d.ts

@@ -1,14 +0,0 @@
-import type { SnapshotId } from "../core/facts/types.js";
-import { type GitRepository } from "./repository.js";
-type MaterializedVerificationCandidate = Readonly<{
-    cwd: string;
-    dispose: () => WorktreeLeak | null;
-}>;
-export type WorktreeLeak = Readonly<{
-    path: string;
-    diagnostic: string;
-}>;
-/** Materialize a temporary candidate worktree for verification and own its cleanup. */
-export declare function materializeVerificationCandidate(repository: GitRepository, candidate: SnapshotId): MaterializedVerificationCandidate;
-export declare function readDeliveryDiff(repository: GitRepository, predecessor: SnapshotId, candidate: SnapshotId): string | null;
-export {};

package/build/src/git/verification.js

@@ -1,56 +0,0 @@
-import { randomBytes } from "node:crypto";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import { AuthorityCorruptionError } from "../core/facts/errors.js";
-import { gitObjectIdForSnapshot } from "./identity.js";
-import { runGit } from "./repository.js";
-/** Materialize a temporary candidate worktree for verification and own its cleanup. */
-export function materializeVerificationCandidate(repository, candidate) {
-    const cwd = join(tmpdir(), `keiyaku-v4-verify-${randomBytes(12).toString("hex")}`);
-    runGit(repository, ["worktree", "add", "--detach", cwd, gitObjectIdForSnapshot(candidate)]);
-    return {
-        cwd,
-        dispose: () => {
-            try {
-                runGit(repository, ["worktree", "remove", "--force", cwd]);
-                return null;
-            }
-            catch (error) {
-                return {
-                    path: cwd,
-                    diagnostic: error instanceof Error ? error.message : String(error),
-                };
-            }
-        },
-    };
-}
-/** Resolve both pinned delivery objects through one structured Git batch. */
-function deliverySnapshotAvailability(repository, predecessor, candidate) {
-    const objects = [gitObjectIdForSnapshot(predecessor), gitObjectIdForSnapshot(candidate)];
-    const types = runGit(repository, ["cat-file", "--batch-check=%(objectname) %(objecttype)"], `${objects.join("\n")}\n`).toString("ascii").trimEnd().split("\n").map((record) => record.split(" ")[1]);
-    if (types.includes("missing"))
-        return "unavailable";
-    if (types.some((type) => type !== "commit")) {
-        throw new AuthorityCorruptionError("recorded delivery snapshot is not a Git commit");
-    }
-    return "available";
-}
-export function readDeliveryDiff(repository, predecessor, candidate) {
-    if (deliverySnapshotAvailability(repository, predecessor, candidate) === "unavailable")
-        return null;
-    try {
-        return runGit(repository, [
-            "diff",
-            "--no-ext-diff",
-            "--no-color",
-            gitObjectIdForSnapshot(predecessor),
-            gitObjectIdForSnapshot(candidate),
-        ]).toString("utf8");
-    }
-    catch (error) {
-        // A pruning race after the probes is still Git absence, not a Git error for callers.
-        if (deliverySnapshotAvailability(repository, predecessor, candidate) === "unavailable")
-            return null;
-        throw error;
-    }
-}