@astrosheep/keiyaku 4.1.0 → 4.1.2

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

@@ -3,6 +3,8 @@ import { open } from "node:fs/promises";
 import { setTimeout as delay } from "node:timers/promises";
 import { promisify } from "node:util";
 import crossSpawn from "cross-spawn";
+import { spawnOptionsFor } from "./launch.js";
+export { handoffProcess } from "./launch.js";
 const TERMINATION_GRACE_MS = 250;
 const STREAM_TAIL_BYTES = 16 * 1024;
 function tailCapture(limit) {
@@ -27,9 +29,7 @@ function tailCapture(limit) {
         result() {
             const size = Math.min(total, limit);
             const start = total > limit ? cursor : 0;
-            const value = start === 0
-                ? bytes.subarray(0, size)
-                : Buffer.concat([bytes.subarray(start), bytes.subarray(0, start)]);
+            const value = start === 0 ? bytes.subarray(0, size) : Buffer.concat([bytes.subarray(start), bytes.subarray(0, start)]);
             return { text: value.toString("utf8"), truncated: total > limit };
         },
     };
@@ -38,6 +38,9 @@ function ignoreMissingProcess(error) {
     if (error.code !== "ESRCH")
         throw error;
 }
+function detachedExitStatus(code, signal) {
+    return code === null ? `signal ${signal ?? "unknown"}` : `exit ${code}`;
+}
 const WINDOWS_TERMINATION_TIMEOUT_MS = 1_000;
 const execFileAsync = promisify(execFile);
 async function terminateWindowsTree(pid) {
@@ -52,8 +55,14 @@ export async function terminateOwnedProcess(child, force = false) {
         return;
     let exited = false;
     const exit = new Promise((resolve) => {
-        child.once("exit", () => { exited = true; resolve(); });
-        child.once("close", () => { exited = true; resolve(); });
+        child.once("exit", () => {
+            exited = true;
+            resolve();
+        });
+        child.once("close", () => {
+            exited = true;
+            resolve();
+        });
     });
     if (process.platform === "win32") {
         await terminateWindowsTree(pid);
@@ -89,16 +98,39 @@ export async function terminateOwnedProcess(child, force = false) {
     }
     await exit;
 }
+async function retainDetachedExitEvidence(log, path, from, code, signal) {
+    const status = detachedExitStatus(code, signal);
+    const marker = Buffer.from(`[child ${status}]\n`);
+    let written = 0;
+    while (written < marker.byteLength) {
+        const write = await log.write(marker, written, marker.byteLength - written);
+        if (write.bytesWritten === 0)
+            throw new Error("run log exit marker write made no progress");
+        written += write.bytesWritten;
+    }
+    const evidence = await log.stat();
+    if (evidence.size < from)
+        throw new Error("run log shrank before exit evidence was retained");
+    const referenced = await open(path, "r");
+    try {
+        const current = await referenced.stat();
+        if (current.dev !== evidence.dev || current.ino !== evidence.ino) {
+            throw new Error("run log path changed before exit evidence was retained");
+        }
+        if (current.size < evidence.size)
+            throw new Error("run log path size changed before exit evidence was retained");
+    }
+    finally {
+        await referenced.close();
+    }
+    return { code, signal, log: { path, from, to: evidence.size } };
+}
 export async function spawnDetachedProcess(input) {
     const log = await open(input.log, "a");
+    let launched = false;
     try {
-        const child = spawn(input.argv[0], input.argv.slice(1), {
-            cwd: input.cwd,
-            env: input.env,
-            detached: true,
-            stdio: ["ignore", log.fd, log.fd],
-            windowsHide: true,
-        });
+        const from = (await log.stat()).size;
+        const child = spawn(input.argv[0], input.argv.slice(1), spawnOptionsFor("retained", input, ["ignore", log.fd, log.fd]));
         await new Promise((resolve, reject) => {
             child.once("spawn", resolve);
             child.once("error", reject);
@@ -106,13 +138,43 @@ export async function spawnDetachedProcess(input) {
         if (child.pid === undefined)
             throw new Error("detached process spawned without a pid");
         const pid = child.pid;
+        const exited = new Promise((resolve, reject) => {
+            child.once("close", (code, signal) => {
+                void (async () => {
+                    const status = detachedExitStatus(code, signal);
+                    let failure;
+                    let result;
+                    try {
+                        result = await retainDetachedExitEvidence(log, input.log, from, code, signal);
+                    }
+                    catch (error) {
+                        failure = error;
+                    }
+                    try {
+                        await log.close();
+                    }
+                    catch (error) {
+                        failure ??= error;
+                    }
+                    if (failure !== undefined) {
+                        throw new Error(`pre-admission ${status}: run-log evidence unavailable: ${failure instanceof Error ? failure.message : String(failure)}`);
+                    }
+                    resolve(result);
+                })().catch(reject);
+            });
+        });
+        void exited.catch(() => undefined);
         let state = "active";
         let termination;
-        const invalidate = () => { state = "inert"; };
+        const invalidate = () => {
+            state = "inert";
+        };
         child.once("exit", invalidate);
         child.once("close", invalidate);
+        launched = true;
         return {
             pid,
+            exited,
             terminate(force = false) {
                 if (state === "inert")
                     return Promise.resolve();
@@ -131,7 +193,8 @@ export async function spawnDetachedProcess(input) {
         };
     }
     finally {
-        await log.close();
+        if (!launched)
+            await log.close();
     }
 }
 function terminalOutcome(code, stdout, stderr, consuming) {
@@ -146,13 +209,7 @@ function terminalOutcome(code, stdout, stderr, consuming) {
 async function executeProcess(input, timeoutMs, consumeStdout, spawnProcess = spawn) {
     if (input.signal?.aborted === true)
         return { outcome: { kind: "cancelled" }, pid: null };
-    const child = spawnProcess(input.argv[0], input.argv.slice(1), {
-        cwd: input.cwd,
-        env: input.env,
-        detached: true,
-        stdio: ["ignore", "pipe", "pipe"],
-        windowsHide: true,
-    });
+    const child = spawnProcess(input.argv[0], input.argv.slice(1), spawnOptionsFor("retained", input, ["ignore", "pipe", "pipe"]));
     const stdout = tailCapture(STREAM_TAIL_BYTES);
     const stderr = tailCapture(STREAM_TAIL_BYTES);
     let stop;

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

@@ -1,20 +1,20 @@
 import { spawn } from "node:child_process";
 import { setTimeout as delay } from "node:timers/promises";
+import { spawnOptionsFor } from "./launch.js";
 import { terminateOwnedProcess } from "./run.js";
 const DEFAULT_DRAIN_TIMEOUT_MS = 1_000;
 export function spawnStdioProcess(input) {
-    const child = spawn(input.argv[0], input.argv.slice(1), {
+    const child = spawn(input.argv[0], input.argv.slice(1), spawnOptionsFor("retained", {
         cwd: input.cwd,
         env: input.env ?? process.env,
-        detached: true,
-        stdio: ["pipe", "pipe", "pipe"],
-        windowsHide: true,
-    });
+    }, ["pipe", "pipe", "pipe"]));
     let stderr = "";
     let inputEnded = false;
     let forced;
     child.stderr.setEncoding("utf8");
-    child.stderr.on("data", (chunk) => { stderr = `${stderr}${chunk}`.slice(-4_000); });
+    child.stderr.on("data", (chunk) => {
+        stderr = `${stderr}${chunk}`.slice(-4_000);
+    });
     const exited = new Promise((resolve) => {
         child.once("close", (code, signal) => resolve({ code, signal, stderr: stderr.trim() }));
         child.once("error", (error) => resolve({ code: null, signal: null, stderr: error.message }));
@@ -38,10 +38,7 @@ export function spawnStdioProcess(input) {
             await forced;
             return;
         }
-        const timedOut = await Promise.race([
-            exited.then(() => false),
-            delay(timeoutMs, true, { ref: false }),
-        ]);
+        const timedOut = await Promise.race([exited.then(() => false), delay(timeoutMs, true, { ref: false })]);
         if (timedOut)
             await forceClose();
     };

package/build/src/settings.js

@@ -59,7 +59,9 @@ function namespaceEntries(name, scope, loaded) {
         return { entries: [], failure: { scope, diagnostic: `${name} must be an object of named values` } };
     }
     return {
-        entries: Object.keys(value).sort().map((entryName) => ({
+        entries: Object.keys(value)
+            .sort()
+            .map((entryName) => ({
             name: entryName,
             value: value[entryName],
             source: scope,
@@ -110,5 +112,7 @@ export async function settings(input = {}) {
 export async function projectSettings(root) {
     if (typeof root !== "string" || root.trim().length === 0)
         throw new TypeError("settings root must be a nonblank string");
-    return settingsFromScopes(await readScope(join(resolve(root), ".keiyaku", "settings.json")), { state: { kind: "absent" } });
+    return settingsFromScopes(await readScope(join(resolve(root), ".keiyaku", "settings.json")), {
+        state: { kind: "absent" },
+    });
 }

package/build/src/settlement/holder.js

@@ -1,7 +1,7 @@
 import { createHash } from "node:crypto";
 import { AuthorityCorruptionError } from "../core/facts/errors.js";
 import { contractId } from "../core/facts/types.js";
-import { GIT_REF, updateGitTree, updateRefsAtomically, writeBlob, writeCommit, } from "../git/repository.js";
+import { GIT_REF, updateGitTree, updateRefsAtomically, writeBlob, writeCommit } from "../git/repository.js";
 import { withGitTargetedReadObservation, } from "../git/read-observation.js";
 import { parseTaskId } from "../task/identity.js";
 import { acquireTaskSettlementFence } from "./fence.js";
@@ -107,7 +107,9 @@ async function admitWithTaskHolderFence(repository, taskId, action) {
         try {
             held.close();
         }
-        catch { /* The operation failure remains decisive before admission. */ }
+        catch {
+            /* The operation failure remains decisive before admission. */
+        }
         throw error;
     }
     return finishTaskHolderAdmission(taskId, result, () => held.close());
@@ -117,9 +119,7 @@ export function claimTaskHolderWithFence(repository, taskId, action) {
 }
 export async function releaseTaskHolder(channel, observation, owner) {
     const current = (await readTaskHolderProjectionFromDecision(channel, observation)).get(owner) ?? null;
-    return current === null || current.disposition !== "held"
-        ? null
-        : update({ ...current, disposition: "released" });
+    return current === null || current.disposition !== "held" ? null : update({ ...current, disposition: "released" });
 }
 /** Publish the released holder against the same frozen observation that decided the release. */
 export async function publishTaskHolderRelease(repository, channel, observation, owner) {
@@ -133,16 +133,20 @@ export async function publishTaskHolderRelease(repository, channel, observation,
         parent: observation.admission.snapshot.commit,
         message: `release held Task completion: ${owner}`,
     });
-    const publication = await updateRefsAtomically(repository, [{
+    const publication = await updateRefsAtomically(repository, [
+        {
             ref: GIT_REF,
             newOid: commit,
             expectedOid: observation.admission.snapshot.commit,
-        }]);
+        },
+    ]);
     if (publication.kind === "published")
         return { kind: "released" };
     return {
         kind: "non-published",
-        diagnostic: publication.kind === "non-published" ? detail(publication.error) : "Task holder release publication state is unknown",
+        diagnostic: publication.kind === "non-published"
+            ? detail(publication.error)
+            : "Task holder release publication state is unknown",
     };
 }
 export async function readTaskHolderProjectionFromDecision(channel, observation) {
@@ -179,8 +183,7 @@ export async function releaseTaskHolderWithFence(repository, channel, owner, act
         : admitWithTaskHolderFence(repository, taskId, action);
 }
 export async function readTaskHoldersAt(observation) {
-    const entries = [...observation.snapshot.paths]
-        .filter(([path, entry]) => path.startsWith(HOLDER_PREFIX) && entry.type === "blob");
+    const entries = [...observation.snapshot.paths].filter(([path, entry]) => path.startsWith(HOLDER_PREFIX) && entry.type === "blob");
     const blobs = await observation.readBlobs(entries.map(([, entry]) => entry.oid));
     const holders = [];
     const seen = new Set();

package/build/src/settlement/settle.js

@@ -25,7 +25,12 @@ async function settleTasks(input) {
         observation = await observeContractsForAdmissionAt(repository, channel, [candidate.id], taskHolderObservationSelection());
     }
     catch (error) {
-        lags.push({ kind: "settlement-failed", surface: "task-holder", contractId: candidate.id, diagnostic: diagnostic(error) });
+        lags.push({
+            kind: "settlement-failed",
+            surface: "task-holder",
+            contractId: candidate.id,
+            diagnostic: diagnostic(error),
+        });
         return;
     }
     const state = observation.journals.get(candidate.id)?.state ?? null;
@@ -36,7 +41,12 @@ async function settleTasks(input) {
         holder = (await readTaskHolderProjectionFromDecision(channel, observation)).get(candidate.id) ?? null;
     }
     catch (error) {
-        lags.push({ kind: "settlement-failed", surface: "task-holder", contractId: candidate.id, diagnostic: diagnostic(error) });
+        lags.push({
+            kind: "settlement-failed",
+            surface: "task-holder",
+            contractId: candidate.id,
+            diagnostic: diagnostic(error),
+        });
         return;
     }
     if (holder === null || holder.disposition !== "held")
@@ -47,13 +57,25 @@ async function settleTasks(input) {
         result = await settleTask(world, taskId);
     }
     catch (error) {
-        lags.push({ kind: "settlement-failed", surface: "task", contractId: candidate.id, taskId, diagnostic: diagnostic(error) });
+        lags.push({
+            kind: "settlement-failed",
+            surface: "task",
+            contractId: candidate.id,
+            taskId,
+            diagnostic: diagnostic(error),
+        });
         return;
     }
     if (result.kind === "changed")
         actions.push({ kind: "task", taskId, action: "done" });
     else if (result.kind !== "unchanged") {
-        lags.push({ kind: "settlement-failed", surface: "task", contractId: candidate.id, taskId, diagnostic: taskFailure(result) });
+        lags.push({
+            kind: "settlement-failed",
+            surface: "task",
+            contractId: candidate.id,
+            taskId,
+            diagnostic: taskFailure(result),
+        });
         return;
     }
     try {
@@ -69,7 +91,13 @@ async function settleTasks(input) {
         }
     }
     catch (error) {
-        lags.push({ kind: "settlement-failed", surface: "task-holder", contractId: candidate.id, taskId, diagnostic: diagnostic(error) });
+        lags.push({
+            kind: "settlement-failed",
+            surface: "task-holder",
+            contractId: candidate.id,
+            taskId,
+            diagnostic: diagnostic(error),
+        });
     }
 }
 async function settleNamespace(state, effects, actions, lags) {
@@ -111,7 +139,12 @@ async function settleObserved(input) {
             });
         }
         catch (error) {
-            lags.push({ kind: "settlement-failed", surface: "task", contractId: input.state.id, diagnostic: diagnostic(error) });
+            lags.push({
+                kind: "settlement-failed",
+                surface: "task",
+                contractId: input.state.id,
+                diagnostic: diagnostic(error),
+            });
         }
     }
     await settleNamespace(input.state, input.effects, actions, lags);

package/build/src/task/board.js

@@ -73,12 +73,16 @@ export function projectDetailFacts(board, id, relations) {
         needs,
         blockers: needs.filter((need) => !need.released).map(({ released: _released, ...ref }) => ref),
         blocks: relations.blocks(id),
-        parent: task.parent === null ? null : taskRef(board, task.parent), children: relations.children(id),
-        supersedes: task.supersedes.map((target) => taskRef(board, target)), supersededBy: relations.supersededBy(id),
+        parent: task.parent === null ? null : taskRef(board, task.parent),
+        children: relations.children(id),
+        supersedes: task.supersedes.map((target) => taskRef(board, target)),
+        supersededBy: relations.supersededBy(id),
         related: relations.related(id),
     };
 }
-function inScope(task, scope) { return scope === null || sameNamespace(parseTaskId(task.id).namespace, scope); }
+function inScope(task, scope) {
+    return scope === null || sameNamespace(parseTaskId(task.id).namespace, scope);
+}
 export function projectTaskRow(board, relations, task) {
     const children = relations.children(task.id);
     const total = children.length;
@@ -95,8 +99,10 @@ export function projectTaskRow(board, relations, task) {
     };
 }
 export function projectRows(board, relations, scope, selection) {
-    return [...board.tasks.values()].filter((task) => inScope(task, scope)).filter((task) => selection === "all"
-        || (selection === "closed") === terminal(task.state)).map((task) => projectTaskRow(board, relations, task))
+    return [...board.tasks.values()]
+        .filter((task) => inScope(task, scope))
+        .filter((task) => selection === "all" || (selection === "closed") === terminal(task.state))
+        .map((task) => projectTaskRow(board, relations, task))
         .sort((a, b) => a.priority - b.priority || Buffer.compare(Buffer.from(a.id), Buffer.from(b.id)));
 }
 export function projectBlocked(board, scope, relations) {
@@ -123,7 +129,7 @@ export function projectTaskBoardObservation(board) {
     };
 }
 function relationIds(task, relation) {
-    return relation === "parent" ? task.parent === null ? [] : [task.parent] : task[relation];
+    return relation === "parent" ? (task.parent === null ? [] : [task.parent]) : task[relation];
 }
 export function relationProblem(board, before, after) {
     for (const relation of ["needs", "parent", "supersedes", "relates"]) {

package/build/src/task/compose.js

@@ -4,7 +4,9 @@ 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 failure(diagnostic) {
+    return { kind: "invalid-composition", diagnostic };
+}
 function parseNamespace(value) {
     if (value === "")
         return [];
@@ -30,14 +32,32 @@ function parseNode(text, depth, index) {
         const title = values.slice(0, at < 0 ? values.length : at).join(" ");
         if (title.trim().length === 0)
             throw new TypeError("compose + node requires a title");
-        return { index, depth, kind: "new", title, assignments: (at < 0 ? [] : values.slice(at)).map((token) => assignment(token) ?? (() => { throw new TypeError(`invalid assignment token: ${token}`); })()) };
+        return {
+            index,
+            depth,
+            kind: "new",
+            title,
+            assignments: (at < 0 ? [] : values.slice(at)).map((token) => assignment(token) ??
+                (() => {
+                    throw new TypeError(`invalid assignment token: ${token}`);
+                })()),
+        };
     }
     const [rawId, ...rest] = tokens;
     if (rawId === undefined || !rawId.startsWith("@task/"))
         throw new TypeError("compose node must begin with + or @task/");
     const id = `task/${rawId.slice(1).slice(5)}`;
     parseTaskId(id);
-    return { index, depth, kind: "existing", id, assignments: rest.map((token) => assignment(token) ?? (() => { throw new TypeError(`invalid assignment token: ${token}`); })()) };
+    return {
+        index,
+        depth,
+        kind: "existing",
+        id,
+        assignments: rest.map((token) => assignment(token) ??
+            (() => {
+                throw new TypeError(`invalid assignment token: ${token}`);
+            })()),
+    };
 }
 function parseSketch(markdown) {
     try {
@@ -73,7 +93,10 @@ function parseSketch(markdown) {
             }
             current.body.push(text.startsWith("\\") ? text.slice(1) : text);
         }
-        const nodes = mutable.map(({ node, body }) => ({ ...node, ...(body.length === 0 ? {} : { body: body.join("\n") }) }));
+        const nodes = mutable.map(({ node, body }) => ({
+            ...node,
+            ...(body.length === 0 ? {} : { body: body.join("\n") }),
+        }));
         return { ...(namespace === undefined ? {} : { namespace }), nodes };
     }
     catch (error) {
@@ -83,14 +106,23 @@ function parseSketch(markdown) {
 function ids(value) {
     if (value === "")
         return [];
-    const parsed = value.split(",").map((raw) => { if (!raw.startsWith("@task/"))
-        throw new TypeError("relation values must be @TaskId"); const id = raw.slice(1); parseTaskId(id); return id; });
+    const parsed = value.split(",").map((raw) => {
+        if (!raw.startsWith("@task/"))
+            throw new TypeError("relation values must be @TaskId");
+        const id = raw.slice(1);
+        parseTaskId(id);
+        return id;
+    });
     if (new Set(parsed).size !== parsed.length)
         throw new TypeError("relation values must not contain duplicates");
     return parsed;
 }
-function scalarId(value) { const values = ids(value); if (values.length > 1)
-    throw new TypeError("parent accepts at most one TaskId"); return values[0] ?? null; }
+function scalarId(value) {
+    const values = ids(value);
+    if (values.length > 1)
+        throw new TypeError("parent accepts at most one TaskId");
+    return values[0] ?? null;
+}
 function changed(current, value, append) {
     return append ? [...current, ...value.filter((id) => !current.includes(id))] : value;
 }
@@ -122,9 +154,19 @@ function currentTimestamp() {
 }
 function createdTask(id, title, at, actor) {
     return {
-        id, title, state: "open", priority: 2, needs: [], parent: null, supersedes: [], relates: [], note: "",
+        id,
+        title,
+        state: "open",
+        priority: 2,
+        needs: [],
+        parent: null,
+        supersedes: [],
+        relates: [],
+        note: "",
         ...(actor === undefined ? {} : { createdBy: actor }),
-        createdAt: at, updatedAt: at, body: "",
+        createdAt: at,
+        updatedAt: at,
+        body: "",
     };
 }
 function plan(sketch, board, defaultNamespace, at, actor) {
@@ -148,7 +190,7 @@ function plan(sketch, board, defaultNamespace, at, actor) {
         const byDepth = [], addressed = new Set();
         const planned = [];
         for (const node of sketch.nodes) {
-            const before = node.kind === "new" ? null : board.tasks.get(node.id) ?? null;
+            const before = node.kind === "new" ? null : (board.tasks.get(node.id) ?? null);
             let current = node.kind === "new" ? allocations.get(node.index) : all.get(node.id);
             if (current === undefined)
                 throw new TypeError(`compose task does not exist: ${node.id}`);
@@ -164,8 +206,8 @@ 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)))) {
+            if (before !== null &&
+                !Buffer.from(serializeTaskDocument(current)).equals(Buffer.from(serializeTaskDocument(before)))) {
                 current = {
                     ...current,
                     updatedAt: advanceTaskTimestamp(before.updatedAt, at),
@@ -187,15 +229,22 @@ function plan(sketch, board, defaultNamespace, at, actor) {
         return failure(error instanceof Error ? error.message : String(error));
     }
 }
-function ref(id) { return `@${id}`; }
-function bodyLines(body) { return body.split("\n").map((line) => /^[\\]|^\+ |^@task\//u.test(line) ? `\\${line}` : line); }
+function ref(id) {
+    return `@${id}`;
+}
+function bodyLines(body) {
+    return body.split("\n").map((line) => (/^[\\]|^\+ |^@task\//u.test(line) ? `\\${line}` : line));
+}
 function draft(namespace, remaining) {
     const lines = [`ns=${namespace.join("/")}`];
     for (const item of remaining) {
         const task = item.after;
         const assignments = [
-            `pri=${task.priority}`, `needs=${task.needs.map(ref).join(",")}`, `parent=${task.parent === null ? "" : ref(task.parent)}`,
-            `supersedes=${task.supersedes.map(ref).join(",")}`, `relates=${task.relates.map(ref).join(",")}`,
+            `pri=${task.priority}`,
+            `needs=${task.needs.map(ref).join(",")}`,
+            `parent=${task.parent === null ? "" : ref(task.parent)}`,
+            `supersedes=${task.supersedes.map(ref).join(",")}`,
+            `relates=${task.relates.map(ref).join(",")}`,
         ];
         lines.push(`${item.node.kind === "new" ? `+ ${task.title}` : ref(task.id)} ${assignments.join(" ")}${task.body === "" ? " body=" : ""}`);
         if (task.body !== "")
@@ -224,19 +273,33 @@ export async function composeTasks(world, markdown, signal, actor, defaultNamesp
         for (let index = 0; index < queue.length; index += 1) {
             signal?.throwIfAborted();
             const item = queue[index], path = authorityPath(world, item.after.id);
-            const beforeBytes = item.before === null ? null : fresh.bytes.get(item.after.id) ?? null;
+            const beforeBytes = item.before === null ? null : (fresh.bytes.get(item.after.id) ?? null);
             const afterBytes = serializeTaskDocument(item.after);
             const before = beforeBytes === null ? "" : Buffer.from(beforeBytes).toString("utf8"), after = Buffer.from(afterBytes).toString("utf8");
             if (before === after)
                 continue;
-            if (await replaceAuthority({ path, expected: beforeBytes, next: afterBytes }) !== "replaced")
+            if ((await replaceAuthority({ path, expected: beforeBytes, next: afterBytes })) !== "replaced")
                 return {
-                    kind: "incomplete", documentChanges: changes, stopped: { kind: "retry", reason: "concurrent-modification" }, draft: draft(namespace, queue.slice(index)),
+                    kind: "incomplete",
+                    documentChanges: changes,
+                    stopped: { kind: "retry", reason: "concurrent-modification" },
+                    draft: draft(namespace, queue.slice(index)),
                 };
             const label = `${item.after.id}.md`;
-            changes.push({ taskId: item.after.id, kind: item.before === null ? "created" : "updated", documentDiff: documentDiff(label, label, before, after) });
+            changes.push({
+                taskId: item.after.id,
+                kind: item.before === null ? "created" : "updated",
+                documentDiff: documentDiff(label, label, before, after),
+            });
         }
         return { kind: "accepted", documentChanges: changes };
     });
-    return result === "busy" ? { kind: "incomplete", documentChanges: [], stopped: { kind: "retry", reason: "busy" }, draft: draft(namespace, ordered) } : result;
+    return result === "busy"
+        ? {
+            kind: "incomplete",
+            documentChanges: [],
+            stopped: { kind: "retry", reason: "busy" },
+            draft: draft(namespace, ordered),
+        }
+        : result;
 }

package/build/src/task/context.js

@@ -2,13 +2,23 @@ import { lstat, mkdir, readFile } from "node:fs/promises";
 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"); }
-function currentPath(root) { return join(directory(root), "current"); }
-function ignorePath(root) { return join(directory(root), ".gitignore"); }
+function directory(root) {
+    return join(root, ".keiyaku", "namespace");
+}
+function currentPath(root) {
+    return join(directory(root), "current");
+}
+function ignorePath(root) {
+    return join(directory(root), ".gitignore");
+}
 function validNamespaceSegments(value) {
-    return Array.isArray(value) && value.every((segment) => typeof segment === "string"
-        && segment.length > 0 && normalizeIdentityStem({ source: segment }) === segment
-        && !segment.includes("/") && segment !== "." && segment !== "..");
+    return (Array.isArray(value) &&
+        value.every((segment) => typeof segment === "string" &&
+            segment.length > 0 &&
+            normalizeIdentityStem({ source: segment }) === segment &&
+            !segment.includes("/") &&
+            segment !== "." &&
+            segment !== ".."));
 }
 async function readAt(root) {
     let bytes;
@@ -66,8 +76,11 @@ export async function repairNamespaceContext(root, segments) {
 }
 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;
+    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);