@astrosheep/keiyaku 4.0.4 → 4.0.6

package/build/src/protocol/review.js

@@ -0,0 +1,156 @@
+import { worktreeChangeId } from "../git/integration.js";
+import { captureTender, dirtyTenderDelta, dirtyTenderRefusal, } from "../git/tender.js";
+import { observeContractsForAdmissionAt } from "../git/observe.js";
+import { dependencyKeySet } from "../core/subject.js";
+import { contractState } from "../core/facts/observation.js";
+import { gate } from "../core/facts/types.js";
+import { decideAttestation } from "../core/verbs/attestation.js";
+import { admitDecidedOffer, mintAttempts } from "./attempt.js";
+import { admitted } from "./outcome.js";
+import { completeCandidate } from "./completion.js";
+import { appointmentFor, readPlaceRegister } from "../workspace-place.js";
+import { timestamp } from "./operations.js";
+const REVIEWED = gate("reviewed");
+async function captureReviewableWorktree(repository, stage) {
+    const appointed = stage.coordinates.workspace === "worktree"
+        ? appointmentFor(await readPlaceRegister(repository), stage.contractId)
+        : undefined;
+    const tender = await captureTender(repository, {
+        ...stage,
+        ...(appointed === undefined ? {} : { place: appointed.place }),
+        ...(stage.workspacePath === undefined ? {} : { workspacePath: stage.workspacePath }),
+    });
+    if (tender.kind === "refused")
+        return tender;
+    if (tender.data.changes.submodules.length > 0) {
+        return { kind: "refused", refusal: await dirtyTenderRefusal(repository, stage.contractId, tender.data) };
+    }
+    const workspace = await dirtyTenderDelta(repository, tender.data);
+    return {
+        kind: "prepared",
+        data: {
+            changeId: await worktreeChangeId(repository, stage, tender.data),
+            tender: tender.data,
+            ...(workspace === undefined ? {} : { workspace }),
+        },
+    };
+}
+export async function prepareReview(repository, stage) {
+    const prepared = await captureReviewableWorktree(repository, stage);
+    if (prepared.kind === "refused")
+        return prepared;
+    return {
+        kind: "prepared",
+        data: {
+            changeId: prepared.data.changeId,
+            ...(prepared.data.workspace === undefined ? {} : { workspace: prepared.data.workspace }),
+        },
+    };
+}
+function reviewValue(value, completion = {}) {
+    return {
+        ...(value.workspace === undefined ? {} : { workspace: value.workspace }),
+        ...completion,
+    };
+}
+async function reviewAttempt(input, attempt) {
+    const decisionObservation = await observeContractsForAdmissionAt(input.scope, input.channel, [input.contractId]);
+    const state = contractState(decisionObservation.decision, input.contractId);
+    let preparation;
+    let workspace;
+    let tender;
+    let workspacePath;
+    if (state !== null) {
+        workspacePath = state.terminal === null && state.coordinates.workspace === "here"
+            ? await input.resolveHereWorkspace?.(state.id)
+            : undefined;
+        const prepared = await captureReviewableWorktree(input.scope, {
+            contractId: state.id,
+            coordinates: state.coordinates,
+            ...(workspacePath === undefined ? {} : { workspacePath }),
+        });
+        preparation = prepared.kind === "refused"
+            ? { kind: "refused", refusal: prepared.refusal }
+            : {
+                kind: "prepared",
+                data: {
+                    gate: REVIEWED,
+                    subject: dependencyKeySet([
+                        { kind: "document", value: state.terms.document.key },
+                        { kind: "change", value: prepared.data.changeId },
+                    ]),
+                    verdict: input.verdict,
+                    ...(input.summary === undefined ? {} : { summary: input.summary }),
+                },
+            };
+        if (prepared.kind === "prepared") {
+            workspace = prepared.data.workspace;
+            tender = prepared.data.tender;
+        }
+    }
+    const decision = decideAttestation({
+        input: {
+            contractId: input.contractId,
+            ...(input.actor === undefined ? {} : { actor: input.actor }),
+            at: timestamp(),
+            ...(preparation === undefined ? {} : { preparation }),
+        },
+        attempt,
+        observation: decisionObservation.decision,
+    });
+    if (decision.kind === "refused")
+        return { kind: "refused", refusal: decision.refusal };
+    const admission = await admitDecidedOffer({
+        channel: input.channel,
+        repository: input.scope,
+        decisionObservation,
+        attempt,
+        offer: decision.offer,
+        primaryContract: input.contractId,
+    });
+    if (admission.kind === "accepted")
+        return {
+            ...admission,
+            value: {
+                ...(workspace === undefined ? {} : { workspace }),
+                ...(tender === undefined ? {} : { tender }),
+                ...(workspacePath === undefined ? {} : { workspacePath }),
+            },
+        };
+    return admission;
+}
+export async function reviewOperation(input) {
+    const git = input.scope;
+    const attempts = mintAttempts({ entryCount: 1 });
+    let review = null;
+    for (let index = 0; index < attempts.length; index += 1) {
+        const result = await reviewAttempt(input, attempts[index]);
+        if (result.kind === "accepted" || result.kind === "refused") {
+            review = result;
+            break;
+        }
+        if (result.kind === "publication-failed")
+            return { kind: "retry", reason: result };
+        if (result.kind === "collision" && index + 1 === attempts.length)
+            return { kind: "retry", reason: result };
+    }
+    if (review === null)
+        return { kind: "retry", reason: { kind: "exhausted" } };
+    if (review.kind !== "accepted")
+        return review;
+    if (input.verdict !== "satisfied")
+        return admitted(review, reviewValue(review.value));
+    const derivation = input.deriveDocument?.(review.state);
+    const completed = await completeCandidate({
+        channel: input.channel,
+        repository: git,
+        contractId: input.contractId,
+        ...(input.actor === undefined ? {} : { actor: input.actor }),
+        ...(review.state.coordinates.target === undefined ? {} : { target: review.state.coordinates.target }),
+        verification: derivation?.verification ?? { kind: "prepared", data: null },
+        initial: review,
+        verifyInitial: false,
+        ...(review.value.workspacePath === undefined ? {} : { hereWorkspacePath: review.value.workspacePath }),
+    });
+    return admitted(completed.admission, reviewValue(review.value, completed.evidence));
+}

package/build/src/protocol/run.d.ts

@@ -1,6 +1,6 @@
 import { type GitDecisionObservation } from "../git/observe.js";
 import type { GitDecodeChannel, GitTreeSelection } from "../git/read-observation.js";
-import type { GitRepository } from "../git/repository.js";
+import type { GitRepository } from "../git/process.js";
 import type { GitRefAssertion } from "../git/repository.js";
 import type { AttemptContext, DecideInput, OfferDecision } from "../core/decide.js";
 import type { Offer, TreeUpdate } from "../core/facts/offer.js";

package/build/src/runtime/proc/run.js

@@ -50,8 +50,14 @@ export async function terminateOwnedProcess(child, force = false) {
     const pid = child.pid;
     if (pid === undefined || child.exitCode !== null || child.signalCode !== null)
         return;
+    let exited = false;
+    const exit = new Promise((resolve) => {
+        child.once("exit", () => { exited = true; resolve(); });
+        child.once("close", () => { exited = true; resolve(); });
+    });
     if (process.platform === "win32") {
         await terminateWindowsTree(pid);
+        await exit;
         return;
     }
     if (force) {
@@ -61,18 +67,15 @@ export async function terminateOwnedProcess(child, force = false) {
         catch (error) {
             ignoreMissingProcess(error);
         }
+        await exit;
         return;
     }
-    let exited = false;
-    const exit = new Promise((resolve) => {
-        child.once("exit", () => { exited = true; resolve(); });
-        child.once("close", () => { exited = true; resolve(); });
-    });
     try {
         process.kill(-pid, "SIGTERM");
     }
     catch (error) {
         ignoreMissingProcess(error);
+        await exit;
         return;
     }
     await Promise.race([exit, delay(TERMINATION_GRACE_MS)]);
@@ -84,6 +87,7 @@ export async function terminateOwnedProcess(child, force = false) {
     catch (error) {
         ignoreMissingProcess(error);
     }
+    await exit;
 }
 export async function spawnDetachedProcess(input) {
     const log = await open(input.log, "a");

package/build/src/settlement/fence.d.ts

@@ -1,5 +1,7 @@
 import { type HeldSqliteTransactionLock } from "../coordination/sqlite-transaction-lock.js";
-import { type GitRepository } from "../git/repository.js";
+import type { GitRepository } from "../git/process.js";
 import type { TaskId } from "../task/identity.js";
 export declare function settlementFencePath(repository: GitRepository, taskId: TaskId): string;
 export declare function acquireTaskSettlementFence(repository: GitRepository, taskId: TaskId): Promise<HeldSqliteTransactionLock>;
+/** Remove only the hash-addressed settlement fences owned by Contract/Git reset. */
+export declare function nukeSettlementFences(repository: GitRepository): Promise<void>;

package/build/src/settlement/fence.js

@@ -1,4 +1,5 @@
 import { createHash } from "node:crypto";
+import { readdir } from "node:fs/promises";
 import { resolve } from "node:path";
 import { acquireSqliteTransactionLock, } from "../coordination/sqlite-transaction-lock.js";
 import { commonGitDirectory } from "../git/repository.js";
@@ -12,3 +13,26 @@ export function acquireTaskSettlementFence(repository, taskId) {
         mode: "immediate",
     });
 }
+/** Remove only the hash-addressed settlement fences owned by Contract/Git reset. */
+export async function nukeSettlementFences(repository) {
+    const root = resolve(commonGitDirectory(repository), "keiyaku", "locks", "settlement");
+    let entries;
+    try {
+        entries = await readdir(root, { withFileTypes: true });
+    }
+    catch (error) {
+        if (error.code === "ENOENT")
+            return;
+        throw error;
+    }
+    for (const entry of entries) {
+        if (!/^[0-9a-f]{64}\.sqlite$/u.test(entry.name) || !entry.isFile() || entry.isSymbolicLink()) {
+            throw new Error(`Settlement fence custody is invalid: ${resolve(root, entry.name)}`);
+        }
+    }
+    for (const entry of entries) {
+        const path = resolve(root, entry.name);
+        const held = await acquireSqliteTransactionLock({ path, mode: "immediate" });
+        held.close();
+    }
+}

package/build/src/settlement/holder.d.ts

@@ -1,7 +1,7 @@
 import type { TreeUpdate } from "../core/facts/offer.js";
 import { type ContractId } from "../core/facts/types.js";
 import type { GitDecisionObservation } from "../git/observe.js";
-import { type GitRepository } from "../git/repository.js";
+import type { GitRepository } from "../git/process.js";
 import { type GitDecodeChannel, type GitReadObservation, type GitTreeSelection } from "../git/read-observation.js";
 import { type TaskId } from "../task/identity.js";
 export declare function taskHolderObservationSelection(): GitTreeSelection;

package/build/src/settlement/settle.d.ts

@@ -1,7 +1,7 @@
 import { type ContractId, type ContractState } from "../core/facts/types.js";
 import type { GitDecodeChannel } from "../git/read-observation.js";
 import type { Effect } from "../git/reconcile.js";
-import type { GitRepository } from "../git/repository.js";
+import type { GitRepository } from "../git/process.js";
 import type { TaskId } from "../task/identity.js";
 export type SettlementAction = Readonly<{
     kind: "task";

package/build/src/settlement/settle.js

@@ -78,11 +78,10 @@ async function settleNamespace(state, effects, actions, lags) {
     const worktrees = effects.filter((effect) => effect.kind === "worktree" && effect.action !== "removed");
     for (const effect of worktrees) {
         try {
-            const world = await World.at(effect.path);
             actions.push({
                 kind: "namespace-context",
                 path: effect.path,
-                action: await repairNamespaceContext(world, contractNamespace(state.id)),
+                action: await repairNamespaceContext(effect.path, contractNamespace(state.id)),
             });
         }
         catch (error) {

package/build/src/task/board.d.ts

@@ -66,7 +66,6 @@ export declare function taskDisposition(board: TaskBoard, task: TaskDocument): T
 export declare function taskBlocked(board: TaskBoard, task: TaskDocument): boolean;
 export declare function projectDetailFacts(board: TaskBoard, id: TaskId, relations: TaskRelationProjection): TaskDetailFacts | null;
 export declare function projectRows(board: TaskBoard, scope: readonly string[] | null, selection: "active" | "closed" | "all"): readonly TaskRow[];
-export declare function projectReady(board: TaskBoard, scope: readonly string[] | null): readonly TaskRow[];
 export declare function projectBlocked(board: TaskBoard, scope: readonly string[] | null, relations: TaskRelationProjection): readonly BlockedTaskRow[];
 export declare function projectStatusRows(board: TaskBoard, scope: readonly string[] | null): (Readonly<{
     id: TaskId;

package/build/src/task/board.js

@@ -86,9 +86,6 @@ export function projectRows(board, scope, selection) {
         disposition: taskDisposition(board, task),
     })).sort((a, b) => a.priority - b.priority || Buffer.compare(Buffer.from(a.id), Buffer.from(b.id)));
 }
-export function projectReady(board, scope) {
-    return projectRows(board, scope, "active").filter((row) => row.disposition === "ready");
-}
 export function projectBlocked(board, scope, relations) {
     return projectRows(board, scope, "active").flatMap((row) => {
         if (!taskBlocked(board, board.tasks.get(row.id)))

package/build/src/task/compose.d.ts

@@ -1,6 +1,6 @@
 import { type TaskId } from "./identity.js";
 import type { WorldRoot } from "../world.js";
-import type { TaskRefusal, TaskRetry } from "./operations.js";
+import { type TaskRefusal, type TaskRetry } from "./operations.js";
 type TaskDocumentChange = Readonly<{
     taskId: TaskId;
     kind: "created" | "updated";
@@ -21,5 +21,5 @@ export type TaskCompositionResult = Readonly<{
     }>;
     draft: string;
 }>;
-export declare function composeTasks(world: WorldRoot, markdown: string, signal?: AbortSignal, actor?: string): Promise<TaskCompositionResult>;
+export declare function composeTasks(world: WorldRoot, markdown: string, signal?: AbortSignal, actor?: string, defaultNamespace?: readonly string[]): Promise<TaskCompositionResult>;
 export {};

package/build/src/task/compose.js

@@ -1,10 +1,9 @@
-import { resolve } from "node:path";
 import { documentDiff } from "../markdown/diff.js";
-import { readNamespaceContext } from "./context.js";
 import { relationProblem } from "./board.js";
 import { serializeTaskDocument } from "./document.js";
 import { allocateLocalId, deriveLocalStem, formatTaskId, parseTaskId, sameNamespace } from "./identity.js";
 import { authorityPath, readBoard, replaceAuthority, withTaskLocks } from "./store.js";
+import { advanceTaskTimestamp } from "./operations.js";
 function failure(diagnostic) { return { kind: "invalid-composition", diagnostic }; }
 function parseNamespace(value) {
     if (value === "")
@@ -118,8 +117,9 @@ function applyAssignments(document, assignments, body) {
     }
     return body === undefined ? next : { ...next, body };
 }
-function currentTimestamp() { return new Date().toISOString(); }
-function advancedTimestamp(previous, current) { return current > previous ? current : new Date(Date.parse(previous) + 1).toISOString(); }
+function currentTimestamp() {
+    return new Date().toISOString();
+}
 function createdTask(id, title, at, actor) {
     return {
         id, title, state: "open", priority: 2, needs: [], parent: null, supersedes: [], relates: [], note: "",
@@ -164,8 +164,13 @@ function plan(sketch, board, defaultNamespace, at, actor) {
                 current = { ...current, parent };
             }
             current = applyAssignments(current, node.assignments, node.body);
-            if (before !== null && !Buffer.from(serializeTaskDocument(current)).equals(Buffer.from(serializeTaskDocument(before))))
-                current = { ...current, updatedAt: advancedTimestamp(before.updatedAt, at) };
+            if (before !== null
+                && !Buffer.from(serializeTaskDocument(current)).equals(Buffer.from(serializeTaskDocument(before)))) {
+                current = {
+                    ...current,
+                    updatedAt: advanceTaskTimestamp(before.updatedAt, at),
+                };
+            }
             byDepth[node.depth] = current.id;
             byDepth.length = node.depth + 1;
             all.set(current.id, current);
@@ -198,15 +203,12 @@ function draft(namespace, remaining) {
     }
     return `${lines.join("\n")}\n`;
 }
-export async function composeTasks(world, markdown, signal, actor) {
+export async function composeTasks(world, markdown, signal, actor, defaultNamespace) {
     const sketch = parseSketch(markdown);
     if ("kind" in sketch)
         return { kind: "refused", refusal: sketch };
     const at = currentTimestamp();
-    const context = sketch.namespace ?? await readNamespaceContext(world);
-    if (context === "malformed")
-        return { kind: "refused", refusal: { kind: "invalid-namespace-context", path: resolve(world, ".keiyaku", "namespace", "current") } };
-    const namespace = context === "absent" ? [] : context;
+    const namespace = sketch.namespace ?? defaultNamespace ?? [];
     const initial = await readBoard(world);
     const planned = plan(sketch, initial.board, namespace, at, actor);
     if ("kind" in planned)

package/build/src/task/context.d.ts

@@ -1,4 +1,16 @@
-export type NamespaceContextRead = readonly string[] | "absent" | "malformed";
-export declare function readNamespaceContext(root: string): Promise<NamespaceContextRead>;
+export type NamespaceContextRead = readonly string[] | "absent" | Readonly<{
+    kind: "malformed";
+    path: string;
+}>;
+export type NamespaceContextInput = Readonly<{
+    directory: string;
+    boundary: string;
+}>;
+export declare function readNamespaceContext(coordinates: NamespaceContextInput): Promise<NamespaceContextRead>;
 export declare function installNamespaceContext(root: string, segments: readonly string[]): Promise<void>;
 export declare function repairNamespaceContext(root: string, segments: readonly string[]): Promise<"kept" | "installed">;
+export declare function resolveTaskNamespaceContext(input: NamespaceContextInput): Promise<readonly string[] | Readonly<{
+    kind: "invalid-namespace-context";
+    path: string;
+}>>;
+export declare function writeTaskNamespaceContext(directory: string, value: readonly string[]): Promise<void>;

package/build/src/task/context.js

@@ -1,5 +1,5 @@
 import { lstat, mkdir, readFile } from "node:fs/promises";
-import { join } from "node:path";
+import { dirname, join, resolve } from "node:path";
 import { repairDerivedFile, replaceFileDurably } from "../coordination/durable-file.js";
 import { normalizeIdentityStem } from "../identity/normalize.js";
 function directory(root) { return join(root, ".keiyaku", "namespace"); }
@@ -10,12 +10,12 @@ function validNamespaceSegments(value) {
         && segment.length > 0 && normalizeIdentityStem({ source: segment }) === segment
         && !segment.includes("/") && segment !== "." && segment !== "..");
 }
-export async function readNamespaceContext(root) {
+async function readAt(root) {
     let bytes;
     try {
         const path = currentPath(root), stat = await lstat(path);
         if (!stat.isFile() || stat.isSymbolicLink())
-            return "malformed";
+            return { kind: "malformed", path };
         bytes = await readFile(path, "utf8");
     }
     catch (error) {
@@ -23,11 +23,26 @@ export async function readNamespaceContext(root) {
             return "absent";
         throw error;
     }
-    if (!bytes.endsWith("\n") || bytes.slice(0, -1).includes("\n"))
-        return "malformed";
+    if (!bytes.endsWith("\n") || bytes.slice(0, -1).includes("\n")) {
+        return { kind: "malformed", path: currentPath(root) };
+    }
     const content = bytes.slice(0, -1);
     const segments = content === "" ? [] : content.split("/");
-    return validNamespaceSegments(segments) ? segments : "malformed";
+    return validNamespaceSegments(segments) ? segments : { kind: "malformed", path: currentPath(root) };
+}
+export async function readNamespaceContext(coordinates) {
+    let current = coordinates.directory;
+    for (;;) {
+        const selected = await readAt(current);
+        if (selected !== "absent")
+            return selected;
+        if (current === coordinates.boundary)
+            return "absent";
+        const resolvedParent = dirname(resolve(current));
+        if (resolvedParent === current || !resolvedParent.startsWith(`${coordinates.boundary}/`))
+            return "absent";
+        current = resolvedParent;
+    }
 }
 export async function installNamespaceContext(root, segments) {
     if (!validNamespaceSegments(segments))
@@ -41,7 +56,7 @@ async function installIgnore(root) {
     await repairDerivedFile(ignorePath(root), "*\n");
 }
 export async function repairNamespaceContext(root, segments) {
-    const current = await readNamespaceContext(root);
+    const current = await readNamespaceContext({ directory: root, boundary: root });
     if (Array.isArray(current)) {
         await installIgnore(root);
         return "kept";
@@ -49,3 +64,11 @@ export async function repairNamespaceContext(root, segments) {
     await installNamespaceContext(root, segments);
     return "installed";
 }
+export async function resolveTaskNamespaceContext(input) {
+    const selected = await readNamespaceContext(input);
+    return selected === "absent" ? [] : typeof selected === "object" && "kind" in selected
+        ? { kind: "invalid-namespace-context", path: selected.path } : selected;
+}
+export async function writeTaskNamespaceContext(directory, value) {
+    await installNamespaceContext(directory, value);
+}

package/build/src/task/index.d.ts

@@ -3,7 +3,7 @@ export type { WorldRoot } from "../world.js";
 import { type BlockedTaskRow, type TaskDetailFacts, type TaskDoctorIssue, type TaskRef, type TaskRow, type TaskTreeNode } from "./board.js";
 import { type TaskCompositionResult } from "./compose.js";
 import { TaskAuthorityCorruptionError, type TaskPriority, type TaskState } from "./document.js";
-import { type TaskId } from "./identity.js";
+import type { TaskId } from "./identity.js";
 import { type AddTaskDocumentInput, type AddTaskInput, type TaskBatchResult, type TaskMutationResult, type TaskOutcome, type TaskRefusal, type TaskRetry, type TaskUpdateResult, type TaskView, type UpdateTaskInput } from "./operations.js";
 import { TASK_RELATION_PREDICATE_FIELDS, type TaskPage, type TaskQueryExpression, type TaskQueryPredicate, type TaskQueryRow, type TaskQuerySort, type TaskRelationPredicateField } from "./query.js";
 export type TaskDetail = Omit<TaskDetailFacts, "task"> & Readonly<{
@@ -53,10 +53,6 @@ declare class TasksHandle {
     private readonly world;
     readonly root: WorldRoot;
     constructor(world: WorldRoot);
-    namespace(): Promise<TaskNamespaceResult>;
-    setNamespace(input: Readonly<{
-        namespace: readonly string[];
-    }>): Promise<void>;
     task(input: Readonly<{
         id: string;
     }>): Task;
@@ -65,21 +61,25 @@ declare class TasksHandle {
     list(input?: Readonly<{
         selection?: "active" | "closed" | "all";
         scope?: "namespace" | "world";
+        namespace?: readonly string[];
         limit?: number;
     }>): Promise<TaskList>;
     ready(input?: Readonly<{
         scope?: "namespace" | "world";
+        namespace?: readonly string[];
         parent?: string;
         limit?: number;
     }>): Promise<TaskList>;
     blocked(input?: Readonly<{
         scope?: "namespace" | "world";
+        namespace?: readonly string[];
         parent?: string;
         limit?: number;
     }>): Promise<BlockedTaskList>;
     query(input?: Readonly<{
         where?: TaskQueryExpression;
         scope?: "namespace" | "world";
+        namespace?: readonly string[];
         sort?: TaskQuerySort;
         limit?: number;
     }>): Promise<TaskQueryResult>;
@@ -92,11 +92,12 @@ declare class TasksHandle {
     }>): Promise<TaskBatchResult>;
     compose(input: Readonly<{
         markdown: string;
+        namespace?: readonly string[];
         actor?: string;
         signal?: AbortSignal;
     }>): Promise<TaskCompositionResult>;
 }
 export type Tasks = TasksHandle;
 export declare const Tasks: Readonly<{
-    of(root: WorldRoot): Tasks;
+    of(world: WorldRoot): Tasks;
 }>;