@astrosheep/keiyaku 2.9.13 → 4.0.1

package/build/src/cli/render/terminal.js

@@ -0,0 +1,151 @@
+const GRAPHEMES = new Intl.Segmenter("und", { granularity: "grapheme" });
+const WIDE_RANGES = [
+    [0x1100, 0x115f], [0x2329, 0x232a], [0x2e80, 0xa4cf], [0xac00, 0xd7a3],
+    [0xf900, 0xfaff], [0xfe10, 0xfe19], [0xfe30, 0xfe6f], [0xff00, 0xff60],
+    [0xffe0, 0xffe6], [0x1f300, 0x1faff], [0x20000, 0x3fffd],
+];
+function characterColumns(character) {
+    const point = character.codePointAt(0);
+    if (point === undefined || point === 0 || /\p{Mark}/u.test(character) || point === 0xfe0f)
+        return 0;
+    if (point < 0x20 || (point >= 0x7f && point < 0xa0))
+        return 0;
+    if (point === 0x303f)
+        return 1;
+    return WIDE_RANGES.some(([first, last]) => point >= first && point <= last) ? 2 : 1;
+}
+export function displayColumns(value) {
+    let columns = 0;
+    for (const character of value)
+        columns += characterColumns(character);
+    return columns;
+}
+export function takeDisplayColumns(value, maximum) {
+    const characters = [...GRAPHEMES.segment(value)].map(({ segment }) => segment);
+    let columns = 0;
+    let index = 0;
+    for (; index < characters.length; index += 1) {
+        const width = displayColumns(characters[index]);
+        if (columns + width > maximum)
+            break;
+        columns += width;
+    }
+    return { text: characters.slice(0, index).join(""), rest: characters.slice(index).join("") };
+}
+export function truncateDisplayText(value, maximum) {
+    const clean = safeText(value);
+    if (displayColumns(clean) <= maximum)
+        return clean;
+    if (maximum <= 0)
+        return "";
+    if (maximum === 1)
+        return "…";
+    return `${takeDisplayColumns(clean, maximum - 1).text.replace(/…+$/u, "")}…`;
+}
+export function truncateMiddleDisplayText(value, maximum) {
+    const clean = safeText(value);
+    if (displayColumns(clean) <= maximum)
+        return clean;
+    if (maximum <= 0)
+        return "";
+    if (maximum === 1)
+        return "…";
+    const available = maximum - 1;
+    const headColumns = Math.ceil(available / 2);
+    const tailColumns = available - headColumns;
+    const head = takeDisplayColumns(clean, headColumns).text.replace(/…+$/u, "");
+    const characters = [...GRAPHEMES.segment(clean)].map(({ segment }) => segment);
+    let tailStart = characters.length;
+    let used = 0;
+    while (tailStart > 0) {
+        const candidate = characters[tailStart - 1];
+        const width = displayColumns(candidate);
+        if (used + width > tailColumns)
+            break;
+        used += width;
+        tailStart -= 1;
+    }
+    return `${head}…${characters.slice(tailStart).join("").replace(/^…+/u, "")}`;
+}
+export function renderBoundedTextBlock(value, input) {
+    const maximumLines = input.lines ?? 3;
+    let rest = safeText(value).replace(/\s+/gu, " ").trim();
+    const lines = [];
+    for (let index = 0; index < maximumLines && rest.length > 0; index += 1) {
+        const prefix = index === 0 ? input.first : input.continuation;
+        const budget = Math.max(1, input.columns - displayColumns(prefix));
+        if (index === maximumLines - 1) {
+            const force = input.truncated === true || displayColumns(rest) > budget;
+            lines.push(`${prefix}${force ? truncateDisplayText(`${rest}…`, budget) : rest}`);
+            rest = "";
+            break;
+        }
+        if (displayColumns(rest) <= budget) {
+            lines.push(`${prefix}${input.truncated === true ? truncateDisplayText(`${rest}…`, budget) : rest}`);
+            rest = "";
+            break;
+        }
+        const taken = takeDisplayColumns(rest, budget);
+        let split = taken.text.lastIndexOf(" ");
+        if (split < Math.floor(taken.text.length / 2))
+            split = taken.text.length;
+        lines.push(`${prefix}${taken.text.slice(0, split).trimEnd()}`);
+        rest = `${taken.text.slice(split)}${taken.rest}`.trimStart();
+    }
+    return lines.length === 0 ? [input.first.trimEnd()] : lines;
+}
+export function safeText(value) {
+    return value.replaceAll(/[\p{Cc}\p{Cf}\p{Zl}\p{Zp}]/gu, (character) => /\s/u.test(character) ? " " : "�");
+}
+export function renderFacts(primary, facts, columns) {
+    const head = safeText(primary);
+    const clean = facts.map(safeText);
+    if (clean.length === 0)
+        return [head];
+    const inline = `${head}  ${clean.join(" · ")}`;
+    if (displayColumns(inline) <= columns)
+        return [inline];
+    const lines = [head];
+    let current = "  ";
+    for (const fact of clean) {
+        const candidate = current === "  " ? `${current}${fact}` : `${current} · ${fact}`;
+        if (current !== "  " && displayColumns(candidate) > columns) {
+            lines.push(current);
+            current = `  ${fact}`;
+        }
+        else
+            current = candidate;
+    }
+    lines.push(current);
+    return lines;
+}
+export function renderTextBlock(value, indent, columns) {
+    const words = safeText(value).trim().split(/\s+/u).filter((word) => word.length > 0);
+    if (words.length === 0)
+        return [indent];
+    const lines = [];
+    let current = indent;
+    for (const word of words) {
+        const candidate = current === indent ? `${indent}${word}` : `${current} ${word}`;
+        if (current !== indent && displayColumns(candidate) > columns) {
+            lines.push(current);
+            current = `${indent}${word}`;
+        }
+        else
+            current = candidate;
+    }
+    lines.push(current);
+    return lines;
+}
+export function renderVoiceRuler(left, right, columns) {
+    const width = Math.max(20, Math.min(80, columns));
+    const occupied = displayColumns(left) + displayColumns(right) + 2;
+    if (occupied >= width)
+        return `${left}\n${"─".repeat(Math.max(1, width - displayColumns(right) - 1))} ${right}`;
+    return `${left} ${"─".repeat(width - occupied)} ${right}`;
+}
+export function tone(value, kind, color) {
+    if (!color)
+        return value;
+    return kind === "dim" ? `\u001b[2m${value}\u001b[0m` : `\u001b[31m${value}\u001b[0m`;
+}

package/build/src/cli/render/text.d.ts

@@ -0,0 +1,3 @@
+import type { InvocationResult } from "../result.js";
+import type { TextRenderContext } from "./terminal.js";
+export declare function renderText(result: InvocationResult, context?: TextRenderContext): string;

package/build/src/cli/render/text.js

@@ -0,0 +1,20 @@
+import { renderObservation } from "./board.js";
+import { renderAccepted, renderRetry } from "./contract.js";
+import { renderKanshiText } from "./kanshi.js";
+import { renderRefusal } from "./refusal.js";
+import { renderCatalogText } from "./catalog.js";
+export function renderText(result, context) {
+    if (result.kind === "guidance")
+        return result.guidance;
+    if (result.kind === "status")
+        return renderKanshiText(result.report, context, result.selection);
+    if (result.kind === "catalog")
+        return renderCatalogText(result.catalog);
+    if (result.kind === "accepted")
+        return renderAccepted(result);
+    if (result.kind === "refused")
+        return renderRefusal(result);
+    if (result.kind === "retry")
+        return renderRetry(result);
+    return renderObservation(result);
+}

package/build/src/cli/result.d.ts

@@ -0,0 +1,67 @@
+import type { AuditReport, ChangeId, ContractId, Fact, PlacementStop, ReconcileReport, RegionOverlap, Review, SettlementReport, SnapshotId, VerificationStop } from "../index.js";
+import type { KanshiReport } from "../kanshi/index.js";
+import type { Catalog } from "../index.js";
+export type Effect = ReconcileReport["effects"][number];
+export type AcceptedFact = Readonly<{
+    contract: ContractId;
+    entry: string;
+    kind: Fact["kind"];
+}>;
+export type Lag = ReconcileReport["lag"][number];
+export type DiffUnavailable = Readonly<{
+    reason: "git-unavailable";
+    integrationSnapshot: SnapshotId;
+    changeId: ChangeId;
+}>;
+export type AcceptedResult = Readonly<{
+    kind: "accepted";
+    verb: string;
+    contract: ContractId;
+    head: string | null;
+    facts: readonly AcceptedFact[];
+    effects: readonly Effect[];
+    settlement: SettlementReport;
+    target?: string | null;
+    verification?: VerificationStop;
+    placement?: PlacementStop;
+    cleanup?: NonNullable<AuditReport["cleanup"]>;
+    leak?: NonNullable<AuditReport["leak"]>;
+    overlaps?: readonly RegionOverlap[];
+    overlapFailure?: string;
+    report?: AuditReport;
+    workspace?: Review["workspace"];
+    diff?: string | DiffUnavailable;
+    lag?: readonly Lag[];
+}>;
+export type RefusedResult = Readonly<{
+    kind: "refused";
+    verb: string;
+    contract?: ContractId;
+    refusal: unknown;
+}>;
+export type RetryResult = Readonly<{
+    kind: "retry";
+    verb: string;
+    contract?: ContractId;
+    detail: unknown;
+}>;
+export type ObservationResult = Readonly<{
+    kind: "observation";
+    command: string;
+    [key: string]: unknown;
+}>;
+export type GuidanceResult = Readonly<{
+    kind: "guidance";
+    contract: ContractId;
+    guidance: string;
+}>;
+export type StatusResult = Readonly<{
+    kind: "status";
+    report: KanshiReport;
+    selection: "world" | "contract";
+}>;
+export type CatalogResult = Readonly<{
+    kind: "catalog";
+    catalog: Catalog;
+}>;
+export type InvocationResult = AcceptedResult | RefusedResult | RetryResult | ObservationResult | GuidanceResult | StatusResult | CatalogResult;

package/build/src/cli/selectors.d.ts

@@ -0,0 +1,9 @@
+import { Keiyaku, type ContractBoard, type ContractId, type Repo } from "../index.js";
+import type { KanshiReport } from "../kanshi/index.js";
+export type SelectedContract = Readonly<{
+    id: ContractId;
+    contract: Keiyaku;
+}>;
+export declare function contractFromInput(repo: Repo, value: string): SelectedContract;
+export declare function resolveContextualContract(board: ContractBoard, selector: string | undefined, scope: string): ContractId;
+export declare function resolveKanshiContract(report: KanshiReport, selector: string): string;

package/build/src/cli/selectors.js

@@ -0,0 +1,66 @@
+import { resolve } from "node:path";
+import { identitySegments } from "../identity/coordinates.js";
+import { Keiyaku } from "../index.js";
+import { CliUsageError } from "./parse.js";
+function selectorError(message) {
+    throw new CliUsageError(message);
+}
+function activeManagedCandidates(rows) {
+    return rows.flatMap((contract) => {
+        if (contract.disposition !== "active" || contract.workspace !== "worktree" || contract.worktreePath === null)
+            return [];
+        return [{ id: contract.id, worktreePath: contract.worktreePath }];
+    });
+}
+export function contractFromInput(repo, value) {
+    try {
+        const id = value;
+        return { id, contract: Keiyaku.of({ repo, id }) };
+    }
+    catch (error) {
+        selectorError(error instanceof Error ? error.message : String(error));
+    }
+}
+function resolveShortContract(rows, selector) {
+    if (selector.startsWith("@kei/"))
+        selectorError(`redundant short contract selector: ${selector}`);
+    const short = selector.slice(1);
+    const candidates = activeManagedCandidates(rows)
+        .filter((candidate) => candidate.id.slice("kei/".length) === short);
+    if (candidates.length === 0)
+        selectorError(`unknown contract selector: ${selector}`);
+    if (candidates.length !== 1)
+        selectorError(`ambiguous contract selector: ${selector}`);
+    return candidates[0].id;
+}
+function resolveOmittedContract(board, scope) {
+    const candidates = activeManagedCandidates(board.rows)
+        .filter((candidate) => resolve(scope) === resolve(candidate.worktreePath));
+    if (candidates.length === 0) {
+        selectorError("an explicit full or @ contract selector is required outside a managed worktree");
+    }
+    if (candidates.length !== 1)
+        selectorError("ambiguous managed worktree contract selector");
+    return candidates[0].id;
+}
+export function resolveContextualContract(board, selector, scope) {
+    if (selector === undefined)
+        return resolveOmittedContract(board, scope);
+    if (selector.startsWith("@"))
+        return resolveShortContract(board.rows, selector);
+    return selectorError(`contract selector must be kei/<contract-segment> or @<contract-segment>: ${selector}`);
+}
+export function resolveKanshiContract(report, selector) {
+    if (report.contracts.kind !== "present") {
+        return selectorError(`cannot select a contract while the Contract world is ${report.contracts.kind}`);
+    }
+    if (selector.startsWith("@"))
+        return resolveShortContract(report.contracts.value.rows, selector);
+    try {
+        identitySegments({ family: "kei", value: selector });
+    }
+    catch {
+        return selectorError(`contract selector must use kei/: ${selector}`);
+    }
+    return selector;
+}

package/build/src/cli/usage.d.ts

@@ -0,0 +1,6 @@
+export declare class CliUsageError extends Error {
+    readonly diagnostic: string;
+    readonly projection?: string | undefined;
+    constructor(diagnostic: string, projection?: string | undefined);
+}
+export declare function usageLine(usage: string): string;

package/build/src/cli/usage.js

@@ -0,0 +1,19 @@
+export class CliUsageError extends Error {
+    diagnostic;
+    projection;
+    constructor(diagnostic, projection) {
+        super(projection === undefined ? diagnostic : `${diagnostic}\n${projection}`);
+        this.diagnostic = diagnostic;
+        this.projection = projection;
+        this.name = "CliUsageError";
+    }
+}
+export function usageLine(usage) {
+    return usage.split("\n").map((line, index) => {
+        if (index === 0)
+            return `usage: keiyaku ${line}`;
+        return line.startsWith("task ")
+            ? `       keiyaku ${line}`
+            : `       ${line.trimStart()}`;
+    }).join("\n");
+}

package/build/src/contract-worktree.d.ts

@@ -0,0 +1,43 @@
+import { type DerivedFileAction } from "./coordination/durable-file.js";
+import { type ContractId, type ContractState } from "./core/facts/types.js";
+import { type GitRepository } from "./git/repository.js";
+export declare function renderContractGuidance(state: ContractState): string;
+export type ContractFileEffect = Readonly<{
+    kind: "contract-file";
+    path: string;
+    action: DerivedFileAction | "removed";
+}>;
+export type ContractFileLag = Readonly<{
+    kind: "contract-file-failed";
+    worktree: string;
+    path: string;
+    diagnostic: string;
+}>;
+export type ContractWorktreeResult = Readonly<{
+    effects: readonly ContractFileEffect[];
+    lag: readonly ContractFileLag[];
+}>;
+export type ContractAppointment = Readonly<{
+    kind: "absent";
+    path: string;
+}> | Readonly<{
+    kind: "appointed";
+    path: string;
+    contract: ContractId;
+}> | Readonly<{
+    kind: "invalid";
+    path: string;
+}>;
+export declare function readContractAppointment(repository: GitRepository): ContractAppointment;
+export type ContractReservation = Readonly<{
+    kind: "reserved";
+    path: string;
+}> | Exclude<ContractAppointment, Readonly<{
+    kind: "absent";
+    path: string;
+}>>;
+export declare function reserveContractWorktree(repository: GitRepository, contract: ContractId): ContractReservation;
+export declare function withContractWorktreeAppointment<T>(repository: GitRepository, action: () => T | Promise<T>): Promise<T>;
+export declare function releaseContractWorktree(repository: GitRepository, contract: ContractId): void;
+export declare function removeContractWorktreeAppointment(repository: GitRepository, contract: ContractId): void;
+export declare function projectContractWorktree(repository: GitRepository, state: ContractState | null): ContractWorktreeResult;

package/build/src/contract-worktree.js

@@ -0,0 +1,213 @@
+import { chmodSync, lstatSync, readFileSync, unlinkSync } from "node:fs";
+import { join } from "node:path";
+import { acquireSqliteTransactionLock } from "./coordination/sqlite-transaction-lock.js";
+import { createFileDurablyExclusive, repairDerivedFile, } from "./coordination/durable-file.js";
+import { contractId } from "./core/facts/types.js";
+import { GitPlumbingError, runGit, worktreeGitDirectory, worktreeRoot, } from "./git/repository.js";
+import { deliveryWorktreePath } from "./git/workspace.js";
+const IGNORE_BYTES = ".gitignore\nKEIYAKU.md\n";
+function appointmentBytes(contract) {
+    return `---\ncontract: ${contract}\n---\n`;
+}
+function renderArc(arc) {
+    return [
+        "## Arc", "", "### Sequence", "", String(arc.seq), "", "### Title", "", arc.title.trimEnd(), "",
+        "### Objective", "", arc.objective.trimEnd(), "", "### Brief", "", arc.brief.trimEnd(),
+    ].join("\n");
+}
+const FULFILLMENT = [
+    "## Fulfillment", "", "### Appointment", "",
+    "Each commission names exactly one seat: Deliverer or Reviewer.",
+    "If no seat was named, stop and ask the caller. Never infer it.", "",
+    "### Worktree", "",
+    "This file is a derived view of the journal-authoritative Contract. Never edit it to change the Contract.",
+    "Treat the directory containing `.keiyaku/KEIYAKU.md` as the Contract worktree root.",
+    "Read the complete Contract before acting and keep work inside that worktree.", "",
+    "### Deliverer", "",
+    "Implement and verify the Objective under the Design, Region, and Criteria in this Contract.",
+    "Leave lifecycle decisions to the caller; report the candidate, verification performed, and any unmet term.", "",
+    "### Reviewer", "",
+    "Review the current candidate against the complete Contract and report material findings with direct evidence.",
+    "Do not modify the candidate. State which Criteria are covered and identify missing or unsupported evidence.",
+].join("\n");
+export function renderContractGuidance(state) {
+    return [
+        appointmentBytes(state.id).trimEnd(),
+        state.terms.document.bytes.trimEnd(),
+        ...(state.currentArc === undefined ? [] : [renderArc(state.currentArc.data)]),
+        FULFILLMENT,
+    ].join("\n\n").concat("\n");
+}
+function isTracked(repository, relativePath) {
+    try {
+        runGit(repository, ["ls-files", "--error-unmatch", "--", relativePath]);
+        return true;
+    }
+    catch (error) {
+        if (error instanceof GitPlumbingError && error.status === 1)
+            return false;
+        throw error;
+    }
+}
+function generatedPath(worktree, name) {
+    return join(worktree, ".keiyaku", name);
+}
+export function readContractAppointment(repository) {
+    const path = generatedPath(worktreeRoot(repository), "KEIYAKU.md");
+    const stat = lstatSync(path, { throwIfNoEntry: false });
+    if (stat === undefined)
+        return { kind: "absent", path };
+    if (!stat.isFile() || stat.isSymbolicLink())
+        return { kind: "invalid", path };
+    const match = /^---\r?\ncontract: ([^\r\n]+)\r?\n---(?:\r?\n|$)/u.exec(readFileSync(path, "utf8"));
+    if (match?.[1] === undefined)
+        return { kind: "invalid", path };
+    try {
+        return { kind: "appointed", path, contract: contractId(match[1]) };
+    }
+    catch {
+        return { kind: "invalid", path };
+    }
+}
+export function reserveContractWorktree(repository, contract) {
+    const worktree = worktreeRoot(repository);
+    const scoped = { ...repository, effectiveCwd: worktree };
+    const ignore = generatedPath(worktree, ".gitignore");
+    if (isTracked(scoped, ".keiyaku/.gitignore"))
+        throw new Error(`generated path is tracked by Git: ${ignore}`);
+    repairDerivedFile(ignore, IGNORE_BYTES);
+    const path = generatedPath(worktree, "KEIYAKU.md");
+    if (isTracked(scoped, ".keiyaku/KEIYAKU.md"))
+        throw new Error(`generated path is tracked by Git: ${path}`);
+    if (createFileDurablyExclusive(path, appointmentBytes(contract), 0o444))
+        return { kind: "reserved", path };
+    const appointment = readContractAppointment(repository);
+    return appointment.kind === "absent" ? { kind: "invalid", path } : appointment;
+}
+export async function withContractWorktreeAppointment(repository, action) {
+    const root = worktreeRoot(repository);
+    const lock = await acquireSqliteTransactionLock({
+        path: join(worktreeGitDirectory(repository, root), "keiyaku", "contract-worktree.sqlite"),
+        mode: "immediate",
+    });
+    try {
+        return await action();
+    }
+    finally {
+        lock.close();
+    }
+}
+export function releaseContractWorktree(repository, contract) {
+    const appointment = readContractAppointment(repository);
+    if (appointment.kind !== "appointed" || appointment.contract !== contract)
+        return;
+    if (readFileSync(appointment.path, "utf8") !== appointmentBytes(contract))
+        return;
+    try {
+        unlinkSync(appointment.path);
+    }
+    catch { /* reservation cleanup is best effort */ }
+}
+export function removeContractWorktreeAppointment(repository, contract) {
+    const appointment = readContractAppointment(repository);
+    if (appointment.kind !== "appointed" || appointment.contract !== contract)
+        return;
+    unlinkSync(appointment.path);
+}
+function repair(repository, worktree, relativePath, bytes) {
+    const path = join(worktree, relativePath);
+    if (isTracked(repository, relativePath))
+        throw new Error(`generated path is tracked by Git: ${path}`);
+    const action = repairDerivedFile(path, bytes);
+    if (relativePath === ".keiyaku/KEIYAKU.md") {
+        try {
+            chmodSync(path, 0o444);
+        }
+        catch { /* advisory protection only */ }
+    }
+    return { kind: "contract-file", path, action };
+}
+function materialize(repository, worktree, guidance) {
+    const stat = lstatSync(worktree, { throwIfNoEntry: false });
+    if (stat === undefined || !stat.isDirectory()) {
+        return {
+            effects: [],
+            lag: [{
+                    kind: "contract-file-failed",
+                    worktree,
+                    path: generatedPath(worktree, "KEIYAKU.md"),
+                    diagnostic: "Contract worktree is unavailable",
+                }],
+        };
+    }
+    const scoped = { ...repository, effectiveCwd: worktree };
+    const effects = [];
+    for (const [relativePath, bytes] of [
+        [".keiyaku/.gitignore", IGNORE_BYTES],
+        [".keiyaku/KEIYAKU.md", guidance],
+    ]) {
+        try {
+            effects.push(repair(scoped, worktree, relativePath, bytes));
+        }
+        catch (error) {
+            return {
+                effects,
+                lag: [{
+                        kind: "contract-file-failed",
+                        worktree,
+                        path: join(worktree, relativePath),
+                        diagnostic: error instanceof Error ? error.message : String(error),
+                    }],
+            };
+        }
+    }
+    return { effects, lag: [] };
+}
+function here(repository, state, guidance) {
+    const worktree = worktreeRoot(repository);
+    const appointment = readContractAppointment(repository);
+    if (appointment.kind === "appointed" && appointment.contract === state.id) {
+        return materialize(repository, worktree, guidance);
+    }
+    const diagnostic = appointment.kind === "appointed"
+        ? `here worktree is appointed to ${appointment.contract}`
+        : `here Contract appointment is ${appointment.kind}`;
+    return {
+        effects: [],
+        lag: [{ kind: "contract-file-failed", worktree, path: appointment.path, diagnostic }],
+    };
+}
+function removeHere(repository, contract) {
+    const worktree = worktreeRoot(repository);
+    const appointment = readContractAppointment(repository);
+    if (appointment.kind === "absent" || (appointment.kind === "appointed" && appointment.contract !== contract)) {
+        return { effects: [], lag: [] };
+    }
+    if (appointment.kind === "invalid") {
+        return { effects: [], lag: [{
+                    kind: "contract-file-failed", worktree, path: appointment.path, diagnostic: "here Contract appointment is invalid",
+                }] };
+    }
+    try {
+        unlinkSync(appointment.path);
+        return { effects: [{ kind: "contract-file", path: appointment.path, action: "removed" }], lag: [] };
+    }
+    catch (error) {
+        return { effects: [], lag: [{
+                    kind: "contract-file-failed",
+                    worktree,
+                    path: appointment.path,
+                    diagnostic: error instanceof Error ? error.message : String(error),
+                }] };
+    }
+}
+export function projectContractWorktree(repository, state) {
+    if (state === null)
+        return { effects: [], lag: [] };
+    if (state.coordinates.workspace === "here") {
+        return state.terminal ? removeHere(repository, state.id) : here(repository, state, renderContractGuidance(state));
+    }
+    return state.terminal
+        ? { effects: [], lag: [] }
+        : materialize(repository, deliveryWorktreePath(repository, state.id), renderContractGuidance(state));
+}

package/build/src/coordination/durable-file.d.ts

@@ -0,0 +1,4 @@
+export declare function replaceFileDurably(path: string, bytes: string | Uint8Array): void;
+export type DerivedFileAction = "created" | "updated" | "unchanged";
+export declare function createFileDurablyExclusive(path: string, bytes: string | Uint8Array, mode?: number): boolean;
+export declare function repairDerivedFile(path: string, bytes: string | Uint8Array): DerivedFileAction;