@astrosheep/keiyaku 4.0.4 → 4.0.5

package/build/src/task/index.js

@@ -1,136 +1,11 @@
 import { buildTree, createTaskRelations, diagnoseBoard, projectDetailFacts, } from "./board.js";
 import { composeTasks } from "./compose.js";
 import { TaskAuthorityCorruptionError } from "./document.js";
-import { isTaskSegment, parseTaskId } from "./identity.js";
 import { addTask, addTaskDocument, batchTasks, blockedTasks, currentNamespace, lifecycleTask, listTasks, queryTasks, readyTasks, setCurrentNamespace, taskView, updateTask, } from "./operations.js";
 import { readBoard } from "./store.js";
-import { isValidTaskLimit, normalizeTaskQuery, TASK_RELATION_PREDICATE_FIELDS, MAX_TASK_LIMIT, DEFAULT_TASK_LIMIT, } from "./query.js";
+import { actor, addInput, closed, limit, namespace, record, signal, sort, taskId as id, taskIds, text, updateInput, } from "./input.js";
+import { normalizeTaskQuery, TASK_RELATION_PREDICATE_FIELDS, DEFAULT_TASK_LIMIT, } from "./query.js";
 export { TaskAuthorityCorruptionError, TASK_RELATION_PREDICATE_FIELDS };
-function record(value, label) {
-    if (typeof value !== "object" || value === null || Array.isArray(value))
-        throw new TypeError(`${label} must be an object`);
-    return value;
-}
-function closed(value, allowed, label) {
-    for (const key of Object.keys(value))
-        if (!allowed.includes(key))
-            throw new TypeError(`${label} has unknown field: ${key}`);
-}
-function id(value) { if (typeof value !== "string")
-    throw new TypeError("task ID must be a string"); parseTaskId(value); return value; }
-function signal(value) {
-    if (value === undefined)
-        return undefined;
-    if (!(value instanceof AbortSignal))
-        throw new TypeError("signal must be an AbortSignal");
-    return value;
-}
-function strings(value, label) {
-    if (value === undefined)
-        return undefined;
-    if (!Array.isArray(value) || !value.every((item) => typeof item === "string"))
-        throw new TypeError(`${label} must be an array of strings`);
-    return value;
-}
-function taskIds(value, label) {
-    const values = strings(value, label)?.map(id);
-    if (values !== undefined && new Set(values).size !== values.length)
-        throw new TypeError(`${label} must not contain duplicates`);
-    return values;
-}
-function namespace(value) {
-    const values = strings(value, "namespace");
-    if (values === undefined)
-        return undefined;
-    if (!values.every(isTaskSegment))
-        throw new TypeError("namespace must contain canonical segments");
-    return values;
-}
-function text(value, label) { if (value === undefined)
-    return undefined; if (typeof value !== "string")
-    throw new TypeError(`${label} must be a string`); return value; }
-function actor(value) {
-    if (value === undefined)
-        return undefined;
-    if (typeof value !== "string" || value.trim().length === 0)
-        throw new TypeError("actor must be a nonblank string");
-    return value;
-}
-function priority(value) { if (value === undefined)
-    return undefined; if (!Number.isInteger(value) || typeof value !== "number" || value < 0 || value > 3)
-    throw new TypeError("priority must be 0..3"); return value; }
-function limit(value) { if (value === undefined)
-    return undefined; if (typeof value !== "number" || !isValidTaskLimit(value))
-    throw new TypeError(`limit must be an integer from 1 to ${MAX_TASK_LIMIT}`); return value; }
-function sort(value) {
-    if (value === undefined)
-        return undefined;
-    if (value !== "priority" && value !== "created" && value !== "updated" && value !== "id")
-        throw new TypeError("sort is invalid");
-    return value;
-}
-function state(value) {
-    if (value === undefined)
-        return undefined;
-    if (value !== "open" && value !== "in_progress" && value !== "on_hold" && value !== "done" && value !== "drop")
-        throw new TypeError("state is invalid");
-    return value;
-}
-function nullableId(value) { return value === undefined || value === null ? value : id(value); }
-function addInput(input) {
-    const v = record(input, "add input");
-    closed(v, ["title", "namespace", "body", "note", "state", "priority", "needs", "parent", "supersedes", "relates", "actor", "signal"], "add input");
-    const title = text(v.title, "title");
-    if (title === undefined || title.trim() === "")
-        throw new TypeError("title is required");
-    const ns = namespace(v.namespace), body = text(v.body, "body"), note = text(v.note, "note"), initialState = state(v.state), pri = priority(v.priority);
-    const needs = taskIds(v.needs, "needs"), parent = nullableId(v.parent), supersedes = taskIds(v.supersedes, "supersedes"), relates = taskIds(v.relates, "relates");
-    const createdBy = actor(v.actor), abort = signal(v.signal);
-    return { title, ...(ns === undefined ? {} : { namespace: ns }), ...(body === undefined ? {} : { body }), ...(note === undefined ? {} : { note }),
-        ...(initialState === undefined ? {} : { state: initialState }), ...(pri === undefined ? {} : { priority: pri }),
-        ...(needs === undefined ? {} : { needs }), ...(parent === undefined ? {} : { parent }),
-        ...(supersedes === undefined ? {} : { supersedes }), ...(relates === undefined ? {} : { relates }),
-        ...(createdBy === undefined ? {} : { actor: createdBy }),
-        ...(abort === undefined ? {} : { signal: abort }) };
-}
-function updateInput(input) {
-    const v = record(input, "update input");
-    closed(v, ["title", "body", "appendBody", "note", "priority", "needs", "addNeeds", "dropNeeds", "parent", "supersedes", "addSupersedes", "dropSupersedes", "relates", "addRelates", "dropRelates", "signal"], "update input");
-    if (v.body !== undefined && v.appendBody !== undefined)
-        throw new TypeError("body and appendBody are mutually exclusive");
-    const result = {};
-    const title = text(v.title, "title");
-    if (title !== undefined) {
-        if (title.trim().length === 0)
-            throw new TypeError("title must be nonblank");
-        result.title = title;
-    }
-    const body = text(v.body, "body");
-    if (body !== undefined)
-        result.body = body;
-    const appendBody = text(v.appendBody, "appendBody");
-    if (appendBody !== undefined)
-        result.appendBody = appendBody;
-    const note = text(v.note, "note");
-    if (note !== undefined)
-        result.note = note;
-    const pri = priority(v.priority);
-    if (pri !== undefined)
-        result.priority = pri;
-    for (const [key, value] of [["needs", taskIds(v.needs, "needs")], ["addNeeds", taskIds(v.addNeeds, "addNeeds")], ["dropNeeds", taskIds(v.dropNeeds, "dropNeeds")], ["supersedes", taskIds(v.supersedes, "supersedes")], ["addSupersedes", taskIds(v.addSupersedes, "addSupersedes")], ["dropSupersedes", taskIds(v.dropSupersedes, "dropSupersedes")], ["relates", taskIds(v.relates, "relates")], ["addRelates", taskIds(v.addRelates, "addRelates")], ["dropRelates", taskIds(v.dropRelates, "dropRelates")]])
-        if (value !== undefined)
-            result[key] = value;
-    const parent = nullableId(v.parent);
-    if (parent !== undefined)
-        result.parent = parent;
-    const abort = signal(v.signal);
-    if (abort !== undefined)
-        result.signal = abort;
-    const update = result;
-    if (Object.keys(result).filter((key) => key !== "signal").length === 0)
-        throw new TypeError("update requires at least one field change");
-    return update;
-}
 class TaskHandle {
     id;
     world;

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

@@ -0,0 +1,18 @@
+import { type TaskPriority, type TaskState } from "./document.js";
+import { type TaskId } from "./identity.js";
+import type { AddTaskInput, UpdateTaskInput } from "./operations.js";
+import { type TaskQuerySort } from "./query.js";
+export declare function record(value: unknown, label: string): Record<string, unknown>;
+export declare function closed(value: Record<string, unknown>, allowed: readonly string[], label: string): void;
+export declare function taskId(value: unknown): TaskId;
+export declare function signal(value: unknown): AbortSignal | undefined;
+export declare function taskIds(value: unknown, label: string): readonly TaskId[] | undefined;
+export declare function namespace(value: unknown): readonly string[] | undefined;
+export declare function text(value: unknown, label: string): string | undefined;
+export declare function actor(value: unknown): string | undefined;
+export declare function priority(value: unknown): TaskPriority | undefined;
+export declare function limit(value: unknown): number | undefined;
+export declare function sort(value: unknown): TaskQuerySort | undefined;
+export declare function state(value: unknown): TaskState | undefined;
+export declare function addInput(input: unknown): AddTaskInput;
+export declare function updateInput(input: unknown): UpdateTaskInput;

package/build/src/task/input.js

@@ -0,0 +1,189 @@
+import { isTaskSegment, parseTaskId } from "./identity.js";
+import { isValidTaskLimit, MAX_TASK_LIMIT } from "./query.js";
+export function record(value, label) {
+    if (typeof value !== "object" || value === null || Array.isArray(value)) {
+        throw new TypeError(`${label} must be an object`);
+    }
+    return value;
+}
+export function closed(value, allowed, label) {
+    for (const key of Object.keys(value)) {
+        if (!allowed.includes(key))
+            throw new TypeError(`${label} has unknown field: ${key}`);
+    }
+}
+export function taskId(value) {
+    if (typeof value !== "string")
+        throw new TypeError("task ID must be a string");
+    parseTaskId(value);
+    return value;
+}
+export function signal(value) {
+    if (value === undefined)
+        return undefined;
+    if (!(value instanceof AbortSignal))
+        throw new TypeError("signal must be an AbortSignal");
+    return value;
+}
+function strings(value, label) {
+    if (value === undefined)
+        return undefined;
+    if (!Array.isArray(value) || !value.every((item) => typeof item === "string")) {
+        throw new TypeError(`${label} must be an array of strings`);
+    }
+    return value;
+}
+export function taskIds(value, label) {
+    const values = strings(value, label)?.map(taskId);
+    if (values !== undefined && new Set(values).size !== values.length) {
+        throw new TypeError(`${label} must not contain duplicates`);
+    }
+    return values;
+}
+export function namespace(value) {
+    const values = strings(value, "namespace");
+    if (values === undefined)
+        return undefined;
+    if (!values.every(isTaskSegment))
+        throw new TypeError("namespace must contain canonical segments");
+    return values;
+}
+export function text(value, label) {
+    if (value === undefined)
+        return undefined;
+    if (typeof value !== "string")
+        throw new TypeError(`${label} must be a string`);
+    return value;
+}
+export function actor(value) {
+    if (value === undefined)
+        return undefined;
+    if (typeof value !== "string" || value.trim().length === 0) {
+        throw new TypeError("actor must be a nonblank string");
+    }
+    return value;
+}
+export function priority(value) {
+    if (value === undefined)
+        return undefined;
+    if (!Number.isInteger(value) || typeof value !== "number" || value < 0 || value > 3) {
+        throw new TypeError("priority must be 0..3");
+    }
+    return value;
+}
+export function limit(value) {
+    if (value === undefined)
+        return undefined;
+    if (typeof value !== "number" || !isValidTaskLimit(value)) {
+        throw new TypeError(`limit must be an integer from 1 to ${MAX_TASK_LIMIT}`);
+    }
+    return value;
+}
+export function sort(value) {
+    if (value === undefined)
+        return undefined;
+    if (value !== "priority" && value !== "created" && value !== "updated" && value !== "id") {
+        throw new TypeError("sort is invalid");
+    }
+    return value;
+}
+export function state(value) {
+    if (value === undefined)
+        return undefined;
+    if (value !== "open" && value !== "in_progress" && value !== "on_hold"
+        && value !== "done" && value !== "drop") {
+        throw new TypeError("state is invalid");
+    }
+    return value;
+}
+function nullableId(value) {
+    return value === undefined || value === null ? value : taskId(value);
+}
+export function addInput(input) {
+    const value = record(input, "add input");
+    closed(value, [
+        "title", "namespace", "body", "note", "state", "priority", "needs", "parent",
+        "supersedes", "relates", "actor", "signal",
+    ], "add input");
+    const title = text(value.title, "title");
+    if (title === undefined || title.trim() === "")
+        throw new TypeError("title is required");
+    const selectedNamespace = namespace(value.namespace);
+    const body = text(value.body, "body");
+    const note = text(value.note, "note");
+    const initialState = state(value.state);
+    const selectedPriority = priority(value.priority);
+    const needs = taskIds(value.needs, "needs");
+    const parent = nullableId(value.parent);
+    const supersedes = taskIds(value.supersedes, "supersedes");
+    const relates = taskIds(value.relates, "relates");
+    const createdBy = actor(value.actor);
+    const abort = signal(value.signal);
+    return {
+        title,
+        ...(selectedNamespace === undefined ? {} : { namespace: selectedNamespace }),
+        ...(body === undefined ? {} : { body }),
+        ...(note === undefined ? {} : { note }),
+        ...(initialState === undefined ? {} : { state: initialState }),
+        ...(selectedPriority === undefined ? {} : { priority: selectedPriority }),
+        ...(needs === undefined ? {} : { needs }),
+        ...(parent === undefined ? {} : { parent }),
+        ...(supersedes === undefined ? {} : { supersedes }),
+        ...(relates === undefined ? {} : { relates }),
+        ...(createdBy === undefined ? {} : { actor: createdBy }),
+        ...(abort === undefined ? {} : { signal: abort }),
+    };
+}
+export function updateInput(input) {
+    const value = record(input, "update input");
+    closed(value, [
+        "title", "body", "appendBody", "note", "priority", "needs", "addNeeds", "dropNeeds",
+        "parent", "supersedes", "addSupersedes", "dropSupersedes", "relates", "addRelates",
+        "dropRelates", "signal",
+    ], "update input");
+    if (value.body !== undefined && value.appendBody !== undefined) {
+        throw new TypeError("body and appendBody are mutually exclusive");
+    }
+    const result = {};
+    const title = text(value.title, "title");
+    if (title !== undefined) {
+        if (title.trim().length === 0)
+            throw new TypeError("title must be nonblank");
+        result.title = title;
+    }
+    const body = text(value.body, "body");
+    if (body !== undefined)
+        result.body = body;
+    const appendBody = text(value.appendBody, "appendBody");
+    if (appendBody !== undefined)
+        result.appendBody = appendBody;
+    const note = text(value.note, "note");
+    if (note !== undefined)
+        result.note = note;
+    const selectedPriority = priority(value.priority);
+    if (selectedPriority !== undefined)
+        result.priority = selectedPriority;
+    for (const [key, ids] of [
+        ["needs", taskIds(value.needs, "needs")],
+        ["addNeeds", taskIds(value.addNeeds, "addNeeds")],
+        ["dropNeeds", taskIds(value.dropNeeds, "dropNeeds")],
+        ["supersedes", taskIds(value.supersedes, "supersedes")],
+        ["addSupersedes", taskIds(value.addSupersedes, "addSupersedes")],
+        ["dropSupersedes", taskIds(value.dropSupersedes, "dropSupersedes")],
+        ["relates", taskIds(value.relates, "relates")],
+        ["addRelates", taskIds(value.addRelates, "addRelates")],
+        ["dropRelates", taskIds(value.dropRelates, "dropRelates")],
+    ])
+        if (ids !== undefined)
+            result[key] = ids;
+    const parent = nullableId(value.parent);
+    if (parent !== undefined)
+        result.parent = parent;
+    const abort = signal(value.signal);
+    if (abort !== undefined)
+        result.signal = abort;
+    if (Object.keys(result).filter((key) => key !== "signal").length === 0) {
+        throw new TypeError("update requires at least one field change");
+    }
+    return result;
+}

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

@@ -0,0 +1,39 @@
+import type { WorldRoot } from "../world.js";
+import type { TaskCompositionResult } from "./compose.js";
+import type { AddTaskDocumentInput, AddTaskInput, TaskBatchResult, TaskMutationResult, TaskUpdateResult, UpdateTaskInput } from "./operations.js";
+import type { TaskId } from "./identity.js";
+export declare const TASK_MUTATION_ACTIONS: readonly ["task.add", "task.addDocument", "task.compose", "task.done", "task.drop", "task.hold", "task.resume", "task.start", "task.stop", "task.update"];
+export type TaskMutationAction = (typeof TASK_MUTATION_ACTIONS)[number];
+export declare function isTaskMutationAction(value: unknown): value is TaskMutationAction;
+export type TaskMutationRequest = Readonly<{
+    action: "task.add";
+    input: Omit<AddTaskInput, "actor" | "signal">;
+}> | Readonly<{
+    action: "task.addDocument";
+    input: Omit<AddTaskDocumentInput, "actor" | "signal">;
+}> | Readonly<{
+    action: "task.compose";
+    markdown: string;
+}> | Readonly<{
+    action: "task.update";
+    id: TaskId;
+    input: Omit<UpdateTaskInput, "signal">;
+}> | Readonly<{
+    action: "task.start" | "task.stop" | "task.resume";
+    id: TaskId;
+}> | Readonly<{
+    action: "task.hold";
+    ids: readonly TaskId[];
+}> | Readonly<{
+    action: "task.done" | "task.drop";
+    ids: readonly TaskId[];
+    note?: string;
+}>;
+export type TaskMutationExecutionResult = TaskMutationResult | TaskUpdateResult | TaskBatchResult | TaskCompositionResult;
+export declare function decodeTaskMutationRequest(action: TaskMutationAction, value: unknown): TaskMutationRequest;
+export declare function executeTaskMutation(input: Readonly<{
+    world: WorldRoot;
+    request: TaskMutationRequest;
+    requester: string;
+    signal?: AbortSignal;
+}>): Promise<TaskMutationExecutionResult>;

package/build/src/task/mutation.js

@@ -0,0 +1,85 @@
+import { addInput, closed, namespace, record, taskId, taskIds, text, updateInput } from "./input.js";
+import { Tasks } from "./index.js";
+export const TASK_MUTATION_ACTIONS = Object.freeze([
+    "task.add", "task.addDocument", "task.compose", "task.done", "task.drop",
+    "task.hold", "task.resume", "task.start", "task.stop", "task.update",
+]);
+const TASK_MUTATION_ACTION_SET = new Set(TASK_MUTATION_ACTIONS);
+export function isTaskMutationAction(value) {
+    return typeof value === "string" && TASK_MUTATION_ACTION_SET.has(value);
+}
+function mutationObject(value, keys, label) {
+    const decoded = record(value, label);
+    closed(decoded, keys, label);
+    return decoded;
+}
+export function decodeTaskMutationRequest(action, value) {
+    switch (action) {
+        case "task.add": {
+            const input = mutationObject(value, ["input"], "task.add request");
+            const raw = mutationObject(input.input, [
+                "title", "namespace", "body", "note", "state", "priority", "needs", "parent", "supersedes", "relates",
+            ], "task.add input");
+            return { action, input: addInput(raw) };
+        }
+        case "task.addDocument": {
+            const input = mutationObject(value, ["input"], "task.addDocument request");
+            const raw = mutationObject(input.input, ["markdown", "namespace"], "task.addDocument input");
+            const markdown = text(raw.markdown, "markdown");
+            if (markdown === undefined)
+                throw new TypeError("markdown is required");
+            const selected = namespace(raw.namespace);
+            return { action, input: { markdown, ...(selected === undefined ? {} : { namespace: selected }) } };
+        }
+        case "task.compose": {
+            const input = mutationObject(value, ["markdown"], "task.compose request");
+            const markdown = text(input.markdown, "markdown");
+            if (markdown === undefined)
+                throw new TypeError("markdown is required");
+            return { action, markdown };
+        }
+        case "task.update": {
+            const request = mutationObject(value, ["id", "input"], "task.update request");
+            const raw = mutationObject(request.input, [
+                "title", "body", "appendBody", "note", "priority", "needs", "addNeeds", "dropNeeds", "parent",
+                "supersedes", "addSupersedes", "dropSupersedes", "relates", "addRelates", "dropRelates",
+            ], "task.update input");
+            return { action, id: taskId(request.id), input: updateInput(raw) };
+        }
+        case "task.start":
+        case "task.stop":
+        case "task.resume": {
+            const request = mutationObject(value, ["id"], `${action} request`);
+            return { action, id: taskId(request.id) };
+        }
+        case "task.hold": {
+            const request = mutationObject(value, ["ids"], "task.hold request");
+            return { action, ids: taskIds(request.ids, "ids") ?? [] };
+        }
+        case "task.done":
+        case "task.drop": {
+            const request = mutationObject(value, ["ids", "note"], `${action} request`);
+            const note = text(request.note, "note");
+            return { action, ids: taskIds(request.ids, "ids") ?? [], ...(note === undefined ? {} : { note }) };
+        }
+    }
+}
+export async function executeTaskMutation(input) {
+    const tasks = Tasks.of(input.world);
+    const { request, signal } = input;
+    const withSignal = signal === undefined ? {} : { signal };
+    switch (request.action) {
+        case "task.add": return await tasks.add({ ...request.input, actor: input.requester, ...withSignal });
+        case "task.addDocument": return await tasks.addDocument({ ...request.input, actor: input.requester, ...withSignal });
+        case "task.compose": return await tasks.compose({ markdown: request.markdown, actor: input.requester, ...withSignal });
+        case "task.update": return await tasks.task({ id: request.id }).update({ ...request.input, ...withSignal });
+        case "task.start": return await tasks.task({ id: request.id }).start(withSignal);
+        case "task.stop": return await tasks.task({ id: request.id }).stop(withSignal);
+        case "task.resume": return await tasks.task({ id: request.id }).resume(withSignal);
+        case "task.hold": return await tasks.batch({ verb: "hold", ids: request.ids, ...withSignal });
+        case "task.done": return await tasks.batch({ verb: "done", ids: request.ids, ...withSignal,
+            ...(request.note === undefined ? {} : { note: request.note }) });
+        case "task.drop": return await tasks.batch({ verb: "drop", ids: request.ids, ...withSignal,
+            ...(request.note === undefined ? {} : { note: request.note }) });
+    }
+}

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

@@ -105,6 +105,8 @@ export type UpdateTaskInput = Readonly<{
     signal?: AbortSignal;
 }>;
 export declare function taskView(document: TaskDocument): TaskView;
+/** Internal Task timestamp rule shared by ordinary mutations and compose. */
+export declare function advanceTaskTimestamp(previous: string, candidate: string): string;
 export declare function addTask(world: WorldRoot, input: AddTaskInput): Promise<TaskMutationResult>;
 export declare function addTaskDocument(world: WorldRoot, input: AddTaskDocumentInput): Promise<TaskMutationResult>;
 export declare function updateTask(world: WorldRoot, id: TaskId, input: UpdateTaskInput): Promise<TaskUpdateResult>;

package/build/src/task/operations.js

@@ -24,10 +24,14 @@ function occupied(board, namespace) {
         return sameNamespace(coordinate.namespace, namespace) ? [coordinate.localId] : [];
     }));
 }
-function currentTimestamp() { return new Date().toISOString(); }
-function advancedTimestamp(previous) {
-    const current = currentTimestamp();
-    return current > previous ? current : new Date(Date.parse(previous) + 1).toISOString();
+function currentTimestamp() {
+    return new Date().toISOString();
+}
+/** Internal Task timestamp rule shared by ordinary mutations and compose. */
+export function advanceTaskTimestamp(previous, candidate) {
+    return candidate > previous
+        ? candidate
+        : new Date(Date.parse(previous) + 1).toISOString();
 }
 function addDocument(base, namespace, board, at, actor) {
     const localId = allocateLocalId(deriveLocalStem(base.title), occupied(board, namespace));
@@ -108,12 +112,20 @@ export async function updateTask(world, id, input) {
         const problem = relationProblem(boardWith(snapshot.board, candidate), current, candidate);
         if (problem !== null)
             return { kind: "refused", refusal: { kind: "invalid-graph", diagnostic: problem } };
-        const predecessor = snapshot.bytes.get(id), before = Buffer.from(predecessor).toString("utf8");
+        const predecessor = snapshot.bytes.get(id);
+        const before = Buffer.from(predecessor).toString("utf8");
         const changed = !Buffer.from(serializeTaskDocument(candidate)).equals(Buffer.from(predecessor));
-        const next = changed ? { ...candidate, updatedAt: advancedTimestamp(current.updatedAt) } : candidate;
-        const afterBytes = serializeTaskDocument(next), after = Buffer.from(afterBytes).toString("utf8");
-        if (before !== after && await replaceAuthority({ path: authorityPath(world, id), expected: predecessor, next: afterBytes }) !== "replaced")
+        let next = candidate;
+        if (changed) {
+            const at = currentTimestamp();
+            next = { ...candidate, updatedAt: advanceTaskTimestamp(current.updatedAt, at) };
+        }
+        const afterBytes = serializeTaskDocument(next);
+        const after = Buffer.from(afterBytes).toString("utf8");
+        if (before !== after
+            && await replaceAuthority({ path: authorityPath(world, id), expected: predecessor, next: afterBytes }) !== "replaced") {
             return { kind: "retry", reason: "concurrent-modification" };
+        }
         const label = `${id}.md`;
         return { kind: "accepted", value: { task: taskView(next), documentDiff: documentDiff(label, label, before, after) } };
     });
@@ -130,9 +142,16 @@ export async function lifecycleTask(world, id, verb, signal, note) {
         if (current === undefined)
             return refused({ kind: "task-missing", taskId: id });
         const state = TRANSITIONS[verb][current.state];
-        if (state === undefined)
+        if (state === undefined) {
             return refused({ kind: "invalid-lifecycle-transition", taskId: id, state: current.state, verb });
-        const next = { ...current, state, ...(note === undefined ? {} : { note }), updatedAt: advancedTimestamp(current.updatedAt) };
+        }
+        const at = currentTimestamp();
+        const next = {
+            ...current,
+            state,
+            ...(note === undefined ? {} : { note }),
+            updatedAt: advanceTaskTimestamp(current.updatedAt, at),
+        };
         const bytes = serializeTaskDocument(next);
         return await replaceAuthority({ path: authorityPath(world, id), expected: snapshot.bytes.get(id), next: bytes }) === "replaced"
             ? { kind: "accepted", value: taskView(next) } : retry("concurrent-modification");
@@ -157,7 +176,12 @@ export async function settleTask(world, id) {
         if (current.state === "drop") {
             return { kind: "refused", refusal: { kind: "invalid-lifecycle-transition", taskId: id, state: current.state, verb: "done" } };
         }
-        const next = { ...current, state: "done", updatedAt: advancedTimestamp(current.updatedAt) };
+        const at = currentTimestamp();
+        const next = {
+            ...current,
+            state: "done",
+            updatedAt: advanceTaskTimestamp(current.updatedAt, at),
+        };
         const replaced = await replaceAuthority({ path: authorityPath(world, id), expected: snapshot.bytes.get(id), next: serializeTaskDocument(next) });
         return replaced === "replaced"
             ? { kind: "changed", task: taskView(next), action: "done" }

package/build/src/task/store.js

@@ -34,8 +34,6 @@ async function authorityFiles(directory) {
             files.push(...await authorityFiles(path));
         else if (entry.isFile() && entry.name.endsWith(".md"))
             files.push(path);
-        else
-            throw new Error(`unexpected Task authority entry: ${path}`);
     }
     return files.sort((a, b) => Buffer.compare(Buffer.from(a), Buffer.from(b)));
 }

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

@@ -1,7 +1,7 @@
 import type { SnapshotId } from "../core/facts/types.js";
 import { type HookFailure } from "../git/hooks.js";
 import type { MaterializedScratchCandidate, WorktreeLeak } from "../git/scratch.js";
-import type { GitRepository } from "../git/repository.js";
+import type { GitRepository } from "../git/process.js";
 import type { Settings } from "../settings.js";
 import type { VerificationDeclaration } from "./declaration.js";
 type VerificationVerdict = "satisfied" | "unsatisfied";

package/build/src/workspace-place.d.ts

@@ -1,5 +1,5 @@
 import { type ContractId } from "./core/facts/types.js";
-import type { GitRepository } from "./git/repository.js";
+import type { GitRepository } from "./git/process.js";
 export declare const CONTRACT_PLACES: readonly string[];
 export type Place = string & {
     readonly [placeBrand]: "Place";
@@ -27,15 +27,12 @@ export type ManagedWorktreeAppointment = Readonly<{
 export declare function placeRegisterPath(repository: GitRepository): string;
 export declare function place(value: string): Place;
 export declare function nextPlace(current?: Place): Place;
-export declare function firstFreePlace(register: PlaceRegister): Place;
 export declare function canonicalPlaceRegister(register: PlaceRegister): string;
 export declare function decodePlaceRegister(path: string, bytes: string): PlaceRegister;
 export declare function emptyPlaceRegister(): PlaceRegister;
 export declare function readPlaceRegister(repository: GitRepository): Promise<PlaceRegister>;
 export declare function appointmentFor(register: PlaceRegister, contract: ContractId): PlaceAppointment | undefined;
 export declare function appointManagedWorktrees(repository: GitRepository, contracts: readonly ContractId[]): Promise<PlaceRegister>;
-export declare function appointManagedWorktree(repository: GitRepository, contract: ContractId): Promise<PlaceAppointment>;
 export declare function releaseManagedWorktrees(repository: GitRepository, contracts: readonly ContractId[]): Promise<void>;
-export declare function releaseManagedWorktree(repository: GitRepository, contract: ContractId): Promise<void>;
 export declare function readManagedWorktreeAppointment(repository: GitRepository, contract: ContractId, register?: PlaceRegister): Promise<ManagedWorktreeAppointment>;
 export {};

package/build/src/workspace-place.js

@@ -230,12 +230,6 @@ export function nextPlace(current) {
         ? composePlace(CONTRACT_PLACES[index + 1], parsed.generation)
         : composePlace(CONTRACT_PLACES[0], parsed.generation + 1n);
 }
-export function firstFreePlace(register) {
-    for (let candidate = nextPlace();; candidate = nextPlace(candidate)) {
-        if (!register.byPlace.has(candidate))
-            return candidate;
-    }
-}
 export function canonicalPlaceRegister(register) {
     const appointments = Object.fromEntries(register.appointments
         .slice()
@@ -354,12 +348,6 @@ function withAppointments(register, contracts) {
 export async function appointManagedWorktrees(repository, contracts) {
     return await mutatePlaceRegister(repository, (current) => withAppointments(current, contracts));
 }
-export async function appointManagedWorktree(repository, contract) {
-    const appointed = appointmentFor(await appointManagedWorktrees(repository, [contract]), contract);
-    if (appointed === undefined)
-        throw new Error(`Place appointment was not recorded: ${contract}`);
-    return appointed;
-}
 export async function releaseManagedWorktrees(repository, contracts) {
     if (contracts.length === 0)
         return;
@@ -369,9 +357,6 @@ export async function releaseManagedWorktrees(repository, contracts) {
         return kept.length === current.appointments.length ? current : indexedRegister(kept);
     });
 }
-export async function releaseManagedWorktree(repository, contract) {
-    await releaseManagedWorktrees(repository, [contract]);
-}
 export async function readManagedWorktreeAppointment(repository, contract, register) {
     try {
         const snapshot = register ?? await readPlaceRegister(repository);