@astrosheep/keiyaku 4.5.5 → 4.5.7

package/build/src/cli/commands/task-invoke.js

@@ -1,4 +1,6 @@
+/* eslint-disable max-lines -- Task edge keeps native reads, forwarding, and local dispatch together. */
 import { Tasks, } from "../../task/index.js";
+import { taskCompositionNamespaceHeader } from "../../task/compose-language.js";
 import { observeTaskDetails } from "../../task/operations.js";
 import { injectedBodyRequests, requestBodyTask } from "../../akuma/requests.js";
 import { decodeTaskMutationRequest } from "../../task/mutation.js";
@@ -8,6 +10,7 @@ export async function invokeTaskFromEdge(input) {
     try {
         return await invokeTask(input.parsed, {
             world: input.world,
+            candidate: input.candidate,
             context: input.context,
             establish: input.establish,
             readStdin: input.readStdin,
@@ -190,11 +193,11 @@ function lifecycleMutationRequest(command) {
             throw new Error(`task action cannot forward: ${command.action}`);
     }
 }
-async function mutationRequest(command, input, current) {
+async function mutationRequest(command, input, current, composeMarkdown) {
     if (command.action === "add")
         return await addMutationRequest(command, input, current);
     if (command.action === "compose")
-        return { action: "task.compose", markdown: await input.readStdin(), namespace: current };
+        return { action: "task.compose", markdown: composeMarkdown ?? (await input.readStdin()), namespace: current };
     if (command.action === "update")
         return await updateMutationRequest(command, input);
     return lifecycleMutationRequest(command);
@@ -293,22 +296,25 @@ function missingWorld(command) {
     });
     if (isWorldObservation(command))
         return { kind: "absent" };
-    if (command.action === "namespace")
-        return { kind: "accepted", value: [] };
+    if (command.action === "compose" && command.flags.plan === true)
+        return { kind: "absent" };
+    if (command.action === "context")
+        return { kind: "accepted", value: { namespace: [], source: "default-root" } };
     if (command.action === "hold" || command.action === "done" || command.action === "drop") {
         return { items: command.positionals.map((id) => ({ id: id, outcome: missing(id) })) };
     }
     return missing(command.positionals[0]);
 }
-async function invokeLocalMutation(tasks, command, input, current) {
+async function invokeLocalMutation(input) {
+    const { tasks, command, edge, current, composeMarkdown, composeNamespace } = input;
     if (isWorldObservation(command))
         return observeWorldRead(tasks, command, current);
     if (command.action === "show" || command.action === "tree")
         return invokeRead(tasks, command, current);
     if (command.action === "add")
-        return await invokeAdd(tasks, command, input, current ?? []);
+        return await invokeAdd(tasks, command, edge, current ?? []);
     if (command.action === "update")
-        return await invokeUpdate(tasks, command, input.readStdin);
+        return await invokeUpdate(tasks, command, edge.readStdin);
     const id = command.positionals[0];
     switch (command.action) {
         case "start":
@@ -327,17 +333,23 @@ async function invokeLocalMutation(tasks, command, input, current) {
             const note = value(command, "note");
             return tasks.batch({ verb: "drop", ids: command.positionals, ...(note === undefined ? {} : { note }) });
         }
-        case "namespace": {
+        case "context": {
             const selected = namespace(command.positionals[0]);
-            if (selected !== undefined)
-                await writeTaskNamespaceContext(input.context.directory, selected);
-            return { kind: "accepted", value: selected ?? current ?? [] };
+            if (selected !== undefined) {
+                await writeTaskNamespaceContext(edge.context.writeRoot ?? edge.context.directory, selected);
+                const resolved = await resolveTaskNamespaceContext(edge.context);
+                if (typeof resolved === "object" && "kind" in resolved)
+                    return { kind: "refused", refusal: resolved };
+                return { kind: "accepted", value: resolved };
+            }
+            return { kind: "accepted", value: { namespace: current ?? [], source: "default-root" } };
         }
         case "compose":
             return tasks.compose({
-                markdown: await input.readStdin(),
-                namespace: current ?? [],
-                ...(input.actor === undefined ? {} : { actor: input.actor }),
+                markdown: composeMarkdown ?? (await edge.readStdin()),
+                namespace: composeNamespace ?? current ?? [],
+                ...(edge.actor === undefined ? {} : { actor: edge.actor }),
+                ...(command.flags.plan === true ? { plan: true } : {}),
             });
         default:
             throw new Error(`task action has no invocation: ${command.action}`);
@@ -345,23 +357,33 @@ async function invokeLocalMutation(tasks, command, input, current) {
 }
 function establishesWorld(command) {
     return (command.action === "add" ||
-        command.action === "compose" ||
-        (command.action === "namespace" && command.positionals.length > 0));
+        (command.action === "compose" && command.flags.plan !== true) ||
+        (command.action === "context" && command.positionals.length > 0));
 }
 function forwardsMutation(command) {
     return (command.action !== "show" &&
         command.action !== "tree" &&
-        command.action !== "namespace" &&
+        command.action !== "context" &&
+        !(command.action === "compose" && command.flags.plan === true) &&
         !isWorldObservation(command));
 }
+// eslint-disable-next-line complexity -- this is the single CLI edge ordering world, context, forwarding, and local execution.
 export async function invokeTask(command, input) {
-    const world = input.world ?? (establishesWorld(command) ? await input.establish() : null);
+    const planOnly = command.action === "compose" && command.flags.plan === true;
+    const composeMarkdown = command.action === "compose" ? await input.readStdin() : undefined;
+    const composition = composeMarkdown === undefined ? undefined : taskCompositionNamespaceHeader(composeMarkdown);
+    const explicitNamespace = command.action === "add"
+        ? namespace(value(command, "namespace"))
+        : command.action === "compose" && composition?.specified
+            ? composition.namespace
+            : undefined;
+    const world = input.world ?? (planOnly ? input.candidate : establishesWorld(command) ? await input.establish() : null);
     if (world === null)
         return missingWorld(command);
     const tasks = Tasks.of(world);
-    const contextSensitive = command.action === "namespace" ||
-        command.action === "add" ||
-        command.action === "compose" ||
+    const contextSensitive = command.action === "context" ||
+        (command.action === "add" && explicitNamespace === undefined) ||
+        (command.action === "compose" && composition?.specified !== true) ||
         ((command.action === "ls" ||
             command.action === "ready" ||
             command.action === "blocked" ||
@@ -372,12 +394,22 @@ export async function invokeTask(command, input) {
         const resolved = await resolveTaskNamespaceContext(input.context);
         if (typeof resolved === "object" && "kind" in resolved)
             return { kind: "refused", refusal: resolved };
-        current = resolved;
+        current = resolved.namespace;
+        if (command.action === "context" && command.positionals.length === 0) {
+            return { kind: "accepted", value: resolved };
+        }
     }
     const requests = injectedBodyRequests();
     if (requests !== null && forwardsMutation(command)) {
-        const request = validatedMutationRequest(await mutationRequest(command, input, current ?? []));
+        const request = validatedMutationRequest(await mutationRequest(command, input, explicitNamespace ?? current ?? [], composeMarkdown));
         return (await requestBodyTask({ directory: requests, world, request }));
     }
-    return await invokeLocalMutation(tasks, command, input, current);
+    return await invokeLocalMutation({
+        tasks,
+        command,
+        edge: input,
+        ...(current === undefined ? {} : { current }),
+        ...(composeMarkdown === undefined ? {} : { composeMarkdown }),
+        ...(explicitNamespace === undefined ? {} : { composeNamespace: explicitNamespace }),
+    });
 }

package/build/src/cli/commands/task.d.ts

@@ -1,5 +1,5 @@
 import { type TaskQueryExpression } from "./task-query.js";
-export type TaskAction = "add" | "show" | "ls" | "ready" | "blocked" | "tree" | "doctor" | "update" | "query" | "start" | "stop" | "hold" | "resume" | "done" | "drop" | "namespace" | "compose";
+export type TaskAction = "add" | "show" | "ls" | "ready" | "blocked" | "tree" | "doctor" | "update" | "query" | "start" | "stop" | "hold" | "resume" | "done" | "drop" | "context" | "compose";
 type TaskFlagValue = string | true | readonly string[];
 type TaskStdin = "document" | "body" | "append" | "note" | "compose";
 export type ParsedTaskCommand = Readonly<{

package/build/src/cli/commands/task.js

@@ -38,18 +38,21 @@ task add [--namespace <ns>] [--actor <actor>] -`,
         flags: { ...COMMON, closed: "boolean", all: "boolean", world: "boolean", limit: "value" },
         usage: "task ls [--closed | --all] [--world] [--limit <n>]",
         purpose: "List Tasks in the selected scope.",
+        details: "--world lists every namespace in the current Task world.",
     },
     ready: {
         arity: [0, 0],
         flags: { ...COMMON, world: "boolean", parent: "value", limit: "value" },
         usage: "task ready [--world] [--parent <TaskId>] [--limit <n>]",
         purpose: "List open Tasks whose every need is terminal.",
+        details: "--world lists every namespace in the current Task world.",
     },
     blocked: {
         arity: [0, 0],
         flags: { ...COMMON, world: "boolean", parent: "value", limit: "value" },
         usage: "task blocked [--world] [--parent <TaskId>] [--limit <n>]",
         purpose: "List Tasks blocked by dependencies.",
+        details: "--world lists every namespace in the current Task world.",
     },
     query: {
         arity: [0, 0],
@@ -60,6 +63,7 @@ task add [--namespace <ns>] [--actor <actor>] -`,
         details: [
             "fields: state priority title id parent under needs blocks ready blocked created updated",
             "operators: = != < > <= >= ~ and or not ( )",
+            "--world lists every namespace in the current Task world.",
             "examples:",
             "  keiyaku task query --where 'priority <= 1 and ready' --world",
             "  keiyaku task query --where 'updated < 2026-08-06T00:00:00.000Z' --world",
@@ -124,18 +128,36 @@ task add [--namespace <ns>] [--actor <actor>] -`,
         usage: "task drop <TaskId>... [--note <text>]",
         purpose: "Drop one or more Tasks.",
     },
-    namespace: {
+    context: {
         arity: [0, 1],
         flags: COMMON,
-        usage: "task namespace [<namespace>]",
-        purpose: "Read or replace the current Task namespace.",
+        usage: "task context [<namespace>]",
+        purpose: "Read or replace the directory Task context.",
     },
     compose: {
         arity: [0, 0],
         stdin: "compose",
-        flags: { ...COMMON, actor: "value" },
-        usage: "task compose [--actor <actor>] -",
-        purpose: "Admit Task documents independently; partial admission has no cross-file atomicity or rollback.",
+        flags: { ...COMMON, actor: "value", plan: "boolean" },
+        usage: "task compose [--actor <actor>] [--plan] -",
+        purpose: "Plan or admit one explicit Task composition.",
+        details: [
+            "nodes: + <Title> creates; @task/<id> modifies a pre-existing Task",
+            "properties: as = <alias>; pri = 0..3; parent = <ref>|empty",
+            "relations: needs|supersedes|relates with =, +=, or -=",
+            "references: @task/... is pre-existing; ^alias is new in this document",
+            "body: body = clears; body <<TOKEN reads exact content to TOKEN",
+            "TOKEN: [A-Z][A-Z0-9_]* with length 3..32",
+            "example:",
+            "  ns=feature",
+            "  + Parent",
+            "  as = parent",
+            "  pri = 1",
+            "  body <<BODY",
+            "  Exact body bytes.",
+            "  BODY",
+            "  + Child",
+            "  parent = ^parent",
+        ].join("\n"),
     },
 };
 export function isTaskAction(value) {

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

@@ -10,6 +10,8 @@ export type CliCoordinates = Readonly<{
     taskContext: Readonly<{
         directory: string;
         boundary: string;
+        writeRoot: string;
+        managed: boolean;
     }>;
     establishWorld: () => Promise<WorldRoot>;
 }>;

package/build/src/cli/coordinates.js

@@ -1,4 +1,4 @@
-import { realpath } from "node:fs/promises";
+import { lstat, realpath } from "node:fs/promises";
 import { resolve } from "node:path";
 import { NoGitWorldError, Repo } from "../library/repo.js";
 import { World, WorldError } from "../world.js";
@@ -24,6 +24,17 @@ async function discoverRepoAt(coordinate, gitPath) {
         throw error;
     }
 }
+async function managedContractWorktree(root) {
+    try {
+        const stat = await lstat(resolve(root, ".keiyaku", "KEIYAKU.md"));
+        return stat.isFile() && !stat.isSymbolicLink();
+    }
+    catch (error) {
+        if (error.code === "ENOENT")
+            return false;
+        throw error;
+    }
+}
 function repoFor(use, discovery) {
     if (use === "none")
         return undefined;
@@ -72,7 +83,12 @@ export async function resolveCliCoordinates(input) {
         ...(repo === undefined ? {} : { repo }),
         world: world.root,
         candidateWorld: world.candidate,
-        taskContext: { directory: cwd, boundary },
+        taskContext: {
+            directory: cwd,
+            boundary,
+            writeRoot: worldRepo === undefined ? boundary : cwd,
+            managed: await managedContractWorktree(boundary),
+        },
         establishWorld: world.establish,
     };
 }

package/build/src/cli/invoke.js

@@ -318,6 +318,7 @@ async function invokeParsed(invocation, runtime) {
         return await (await import("./commands/task-invoke.js")).invokeTaskFromEdge({
             parsed,
             world,
+            candidate: candidateWorld,
             context: taskContext,
             establish: coordinates.establishWorld,
             readStdin: edge.readStdin,

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

@@ -59,6 +59,9 @@ function projectRefusal(refusal) {
     if (refusal.kind === "relation-owned-by-other") {
         return { line: `relation-owned-by-other ${refusal.taskId} ${refusal.related} ${refusal.declaringTask}` };
     }
+    if (refusal.kind === "invalid-composition") {
+        return { line: refusal.kind, compositionDiagnostics: refusal.diagnostics };
+    }
     return { line: refusal.kind, diagnostic: refusal.diagnostic };
 }
 function appendDiagnostic(lines, diagnostic) {
@@ -73,6 +76,9 @@ function renderFailure(verb, result, columns) {
     const facts = projectRefusal(result.refusal);
     lines.push(facts.line);
     appendDiagnostic(lines, facts.diagnostic);
+    for (const item of facts.compositionDiagnostics ?? []) {
+        lines.push(`line ${item.line} · ${safeText(item.reason)} · ${safeText(item.token)}`);
+    }
     return lines.join("\n");
 }
 function edge(label, ref, mark) {
@@ -256,12 +262,30 @@ function stoppedLines(stopped) {
     appendDiagnostic(lines, facts.diagnostic);
     return lines;
 }
+function aliasLines(aliases) {
+    return aliases.map((binding) => `alias ^${binding.alias} ${binding.taskId}`);
+}
+function renderPlan(result) {
+    const lines = [
+        `compose plan · ${result.admissionOrder.length} documents`,
+        ...aliasLines(result.aliases),
+        ...result.admissionOrder.map((id, index) => `admit ${index + 1} ${id}`),
+    ];
+    for (const body of result.bodies) {
+        lines.push(`body ${body.taskId} · ${body.bytes} bytes`);
+        lines.push(`  first ${safeText(body.firstLine)}`);
+        lines.push(`  last ${safeText(body.lastLine)}`);
+    }
+    return lines.join("\n");
+}
 function renderCompose(result, columns) {
     if (result.kind === "incomplete")
         return "";
+    if (result.kind === "planned")
+        return renderPlan(result);
     if (result.kind !== "accepted")
         return renderFailure("compose", result, columns);
-    const lines = [`✓ compose accepted · ${result.documentChanges.length} changed`];
+    const lines = [`✓ compose accepted · ${result.documentChanges.length} changed`, ...aliasLines(result.aliases)];
     composeDiffs(lines, result.documentChanges);
     return lines.join("\n");
 }
@@ -295,11 +319,12 @@ function renderTaskValue(command, result, columns) {
     }
     if (command.action === "doctor")
         return renderDoctor(result);
-    if (command.action === "namespace") {
-        const namespace = result;
-        if (namespace.kind !== "accepted")
-            return renderFailure(command.action, namespace, columns);
-        return `namespace ${namespace.value.length === 0 ? "root" : namespace.value.join("/")}`;
+    if (command.action === "context") {
+        const context = result;
+        if (context.kind !== "accepted")
+            return renderFailure(command.action, context, columns);
+        const value = context.value.namespace.length === 0 ? "root" : context.value.namespace.join("/");
+        return `context ${value} · ${context.value.source}`;
     }
     if (command.action === "compose")
         return renderCompose(result, columns);

package/build/src/cli/square-edge.js

@@ -44,13 +44,13 @@ export async function recognizeAndListen(worldRoot, environment, allocated) {
             }
         }
         if (bound)
-            unbindCurrentParticipant(path, name, environment);
+            await unbindCurrentParticipant(path, name, environment);
     };
     try {
         const joinedResult = await square.joinWithActivity(name);
         joined = joinedResult.activity !== null;
         const participant = joinedResult.participant;
-        bound = bindCurrentParticipant(path, name, environment).created;
+        bound = (await bindCurrentParticipant(path, name, environment)).created;
         const listener = participant;
         const change = await listener.listen(allocated.id);
         listening = change.activity !== null;

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

@@ -42,6 +42,8 @@ export declare function commonGitDirectory(repository: GitRepository): string;
 export declare function worktreeGitDirectory(repository: GitRepository, worktree: string): Promise<string>;
 export declare function worktreeRoot(repository: GitRepository): Promise<string>;
 export declare function readRef(repository: GitRepository, ref: string): Promise<GitOid | null>;
+/** Read an explicit set of asserted refs from one fresh Git observation. */
+export declare function readRefs(repository: GitRepository, refs: readonly string[]): Promise<Map<any, any>>;
 export declare function readTreeEntries(repository: GitRepository, tree: GitOid): Promise<Map<string, TreeEntry>>;
 export declare function readGit(repository: GitRepository): Promise<GitSnapshot>;
 /** Read only the requested private Git paths from one immutable Git tree. */

package/build/src/git/repository.js

@@ -113,9 +113,6 @@ export async function worktreeGitDirectory(repository, worktree) {
 export async function worktreeRoot(repository) {
     return await absoluteGitPath(repository, ["--show-toplevel"], "worktree root");
 }
-function assertOid(oid, label) {
-    gitObjectId(oid, label);
-}
 function assertRef(ref) {
     if (!ref.startsWith("refs/") || /[\s\0]/.test(ref) || ref.endsWith("/") || ref.includes("..")) {
         throw new Error(`invalid Git ref: ${ref}`);
@@ -129,10 +126,7 @@ export async function readRef(repository, ref) {
     assertAssertionRef(ref);
     try {
         const oid = (await runGit(repository, ["rev-parse", "--verify", "--quiet", ref])).toString("utf8").trim();
-        if (oid.length === 0)
-            return null;
-        assertOid(oid, `ref ${ref}`);
-        return oid;
+        return oid.length === 0 ? null : gitObjectId(oid, `ref ${ref}`);
     }
     catch (error) {
         if (error instanceof GitPlumbingError && error.status === 1)
@@ -140,10 +134,29 @@ export async function readRef(repository, ref) {
         throw error;
     }
 }
+/** Read an explicit set of asserted refs from one fresh Git observation. */
+export async function readRefs(repository, refs) {
+    const refsToRead = [...new Set(refs)];
+    for (const ref of refsToRead)
+        assertAssertionRef(ref);
+    if (refsToRead.length === 0)
+        return new Map();
+    const output = (await runGit(repository, ["cat-file", "--batch-check=%(objectname)"], `${refsToRead.join("\n")}\n`)).toString("utf8");
+    const records = output.split("\n");
+    if (records.pop() !== "" || records.length !== refsToRead.length)
+        throw new Error("Git ref batch output is malformed");
+    return new Map(refsToRead.map((ref, index) => {
+        const oid = records[index];
+        if (oid === `${ref} missing`)
+            return [ref, null];
+        gitObjectId(oid, `ref ${ref}`);
+        return [ref, oid];
+    }));
+}
 async function readTreeForCommit(repository, commit) {
-    assertOid(commit, "Git commit");
+    gitObjectId(commit, "Git commit");
     const tree = (await runGit(repository, ["show", "-s", "--format=%T", commit])).toString("utf8").trim();
-    assertOid(tree, "Git tree");
+    gitObjectId(tree, "Git tree");
     return tree;
 }
 function parseTreeEntries(output) {
@@ -159,13 +172,13 @@ function parseTreeEntries(output) {
         if (mode === undefined || type === undefined || oid === undefined || path.length === 0) {
             throw new GitPlumbingError({ stderr: record, status: null, message: `malformed ls-tree record: ${record}` });
         }
-        assertOid(oid, `tree entry ${path}`);
+        gitObjectId(oid, `tree entry ${path}`);
         entries.set(path, { mode, type, oid });
     }
     return entries;
 }
 export async function readTreeEntries(repository, tree) {
-    assertOid(tree, "tree");
+    gitObjectId(tree, "tree");
     const output = await runGit(repository, ["ls-tree", "-r", "-z", "--full-tree", tree]);
     return parseTreeEntries(output);
 }
@@ -193,11 +206,11 @@ export async function readGitPaths(repository, requestedPaths) {
 }
 export async function writeBlob(repository, bytes) {
     const oid = (await runGit(repository, ["hash-object", "-w", "--stdin"], bytes)).toString("utf8").trim();
-    assertOid(oid, "written blob");
+    gitObjectId(oid, "written blob");
     return oid;
 }
 export async function readBlob(repository, oid) {
-    assertOid(oid, "blob");
+    gitObjectId(oid, "blob");
     return await runGit(repository, ["cat-file", "blob", oid]);
 }
 function malformedBatchOutput(detail) {
@@ -210,7 +223,7 @@ function malformedBatchOutput(detail) {
 async function readObjects(repository, oids) {
     const unique = [...new Set(oids)];
     for (const oid of unique)
-        assertOid(oid, "Git object");
+        gitObjectId(oid, "Git object");
     if (unique.length === 0)
         return new Map();
     const output = await runGit(repository, ["cat-file", "--batch"], `${unique.join("\n")}\n`);
@@ -305,7 +318,7 @@ async function writePreparedTrees(repository, prepared) {
     for (let index = 0; index < prepared.length; index += 1) {
         const expected = prepared[index].oid;
         const actual = written[index];
-        assertOid(actual, "written tree");
+        gitObjectId(actual, "written tree");
         if (actual !== expected) {
             throw new GitPlumbingError({ stderr: output, status: null, message: `mktree wrote unexpected tree: ${actual}` });
         }
@@ -338,9 +351,9 @@ export async function updateGitTreeFromFrozenDirectories(repository, baseTree, d
 }
 async function writeCommitObject(input) {
     const { repository, tree, parents, message, actor, email, at } = input;
-    assertOid(tree, "commit tree");
+    gitObjectId(tree, "commit tree");
     for (const parent of parents)
-        assertOid(parent, "commit parent");
+        gitObjectId(parent, "commit parent");
     const args = ["commit-tree", tree];
     for (const parent of parents)
         args.push("-p", parent);
@@ -353,7 +366,7 @@ async function writeCommitObject(input) {
     }))
         .toString("utf8")
         .trim();
-    assertOid(commit, "written Git commit");
+    gitObjectId(commit, "written Git commit");
     return commit;
 }
 export async function writeCommit(input) {
@@ -369,7 +382,7 @@ export async function writeCommit(input) {
 }
 function refAssertionLine(assertion) {
     assertAssertionRef(assertion.ref);
-    assertOid(assertion.oid, `expected oid for ${assertion.ref}`);
+    gitObjectId(assertion.oid, `expected oid for ${assertion.ref}`);
     return `${assertion.ref === "HEAD" ? "" : "option no-deref\n"}verify ${assertion.ref} ${assertion.oid}`;
 }
 function refUpdateLine(update, index) {
@@ -378,9 +391,9 @@ function refUpdateLine(update, index) {
         throw new Error(`duplicate ref update: ${update.ref}`);
     if (index > 0 && update.expectedOid === null)
         throw new Error("target ref updates require non-null OIDs");
-    assertOid(update.newOid, `new oid for ${update.ref}`);
+    gitObjectId(update.newOid, `new oid for ${update.ref}`);
     if (update.expectedOid !== null)
-        assertOid(update.expectedOid, `expected oid for ${update.ref}`);
+        gitObjectId(update.expectedOid, `expected oid for ${update.ref}`);
     return `option no-deref\nupdate ${update.ref} ${update.newOid} ${update.expectedOid ?? "0".repeat(update.newOid.length)}`;
 }
 export async function updateRefsAtomically(repository, updates, assertions = []) {

package/build/src/git/target-placement.js

@@ -280,8 +280,6 @@ async function classifyCheckout(input) {
     const candidateWorkspace = await workspaceMatchesTreeOnPaths(repository, path, candidateTree, workspaceTree, changedPaths);
     if (candidateIndex && candidateWorkspace)
         return { kind: "complete" };
-    if (workspaceTree === candidateTree)
-        return { kind: "recoverable", action: "candidate-index" };
     const predecessorIndex = await indexMatchesTreeOnPaths(repository, path, predecessorTree, changedPaths);
     if (predecessorIndex && candidateWorkspace)
         return { kind: "recoverable", action: "index-merge" };
@@ -305,10 +303,6 @@ async function recoverCheckout(input) {
     if (classified.kind === "retained")
         return "retained";
     const { repository, path, predecessor, candidate } = input;
-    if (classified.action === "candidate-index") {
-        await runGit(repository, ["-C", path, "read-tree", gitObjectIdForSnapshot(candidate)]);
-        return "recovered";
-    }
     if (classified.action === "index-merge") {
         await runGit(repository, [
             "-C",

package/build/src/protocol/attempt.js

@@ -2,7 +2,7 @@ import { randomBytes } from "node:crypto";
 import { encodeEntry } from "../core/facts/codec.js";
 import { admit } from "../git/admission.js";
 import { observeContractsForAdmissionAt } from "../git/observe.js";
-import { GIT_REF, readRef } from "../git/repository.js";
+import { GIT_REF, readRefs } from "../git/repository.js";
 import { foldJournal } from "../core/facts/fold.js";
 import { AuthorityCorruptionError } from "../core/facts/errors.js";
 import { entryUlid, } from "../core/facts/types.js";
@@ -78,12 +78,17 @@ function recoveredAcceptance(observation, offer, primaryContract) {
     };
 }
 async function publicationPremiseMoved(repository, observation, offer, assertions) {
-    if ((await readRef(repository, GIT_REF)) !== observation.admission.snapshot.commit)
+    const refs = await readRefs(repository, [
+        GIT_REF,
+        ...assertions.map((assertion) => assertion.ref),
+        ...(offer.target === undefined ? [] : [offer.target.target]),
+    ]);
+    if (refs.get(GIT_REF) !== observation.admission.snapshot.commit)
         return true;
     for (const assertion of assertions)
-        if ((await readRef(repository, assertion.ref)) !== assertion.oid)
+        if (refs.get(assertion.ref) !== assertion.oid)
             return true;
-    return offer.target !== undefined && (await readRef(repository, offer.target.target)) !== offer.target.expectedOid;
+    return offer.target !== undefined && refs.get(offer.target.target) !== offer.target.expectedOid;
 }
 /** Admit one decided offer without making another legal decision. */
 export async function admitDecidedOffer(input) {

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

@@ -0,0 +1,47 @@
+import type { TaskBoard } from "./board.js";
+import { type TaskDocument } from "./document.js";
+import { type TaskId } from "./identity.js";
+import { type TaskCompositionDiagnostic } from "./operations.js";
+export declare function taskCompositionNamespaceHeader(markdown: string): Readonly<{
+    specified: boolean;
+    namespace?: readonly string[];
+}>;
+export type TaskCompositionAlias = Readonly<{
+    alias: string;
+    taskId: TaskId;
+}>;
+export type TaskCompositionBodyPreview = Readonly<{
+    taskId: TaskId;
+    bytes: number;
+    firstLine: string;
+    lastLine: string;
+}>;
+export type PlannedTask = Readonly<{
+    index: number;
+    line: number;
+    kind: "new" | "existing";
+    alias?: string;
+    before: TaskDocument | null;
+    after: TaskDocument;
+}>;
+export type TaskCompositionPlan = Readonly<{
+    namespace: readonly string[];
+    aliases: readonly TaskCompositionAlias[];
+    admissionOrder: readonly TaskId[];
+    bodies: readonly TaskCompositionBodyPreview[];
+    tasks: readonly PlannedTask[];
+}>;
+export type TaskCompositionPlanning = Readonly<{
+    kind: "planned";
+    plan: TaskCompositionPlan;
+}> | Readonly<{
+    kind: "refused";
+    diagnostics: readonly TaskCompositionDiagnostic[];
+}>;
+export declare function planTaskComposition(input: Readonly<{
+    markdown: string;
+    board: TaskBoard;
+    namespace: readonly string[];
+    at: string;
+    actor?: string;
+}>): TaskCompositionPlanning;