@astrosheep/keiyaku 4.5.4 → 4.5.5

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

@@ -47,6 +47,7 @@ export function renderInstallHelp() {
 const INSTALL_TIMEOUT_MS = 5 * 60 * 1000;
 const ASSET_ROOT = resolve(dirname(fileURLToPath(import.meta.url)), "../../../integrations/marketplace");
 const PLUGIN_ROOT = resolve(ASSET_ROOT, "plugins/keiyaku");
+const PI_PACKAGE_SOURCE = "npm:@astrosheep/keiyaku";
 function recipes(harness) {
     switch (harness) {
         case "codex":
@@ -63,7 +64,7 @@ function recipes(harness) {
         case "opencode":
             return [["opencode", "plugin", PLUGIN_ROOT, "--global", "--force"]];
         case "pi":
-            return [["pi", "install", PLUGIN_ROOT]];
+            return [["pi", "install", PI_PACKAGE_SOURCE]];
     }
 }
 function diagnostic(argv, outcome) {

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

@@ -19,7 +19,6 @@ export type TaskWorldObservation = Readonly<{
 }>;
 type TaskInput = Readonly<{
     world: WorldRoot | null;
-    candidate: WorldRoot | null;
     context: Readonly<{
         directory: string;
         boundary: string;
@@ -31,7 +30,6 @@ type TaskInput = Readonly<{
 export declare function invokeTaskFromEdge(input: Readonly<{
     parsed: ParsedTaskCommand;
     world: WorldRoot | null;
-    candidate: WorldRoot | null;
     context: Readonly<{
         directory: string;
         boundary: string;

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

@@ -8,7 +8,6 @@ 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,
@@ -294,15 +293,6 @@ function missingWorld(command) {
     });
     if (isWorldObservation(command))
         return { kind: "absent" };
-    if (command.action === "compose" && command.flags.plan === true) {
-        return {
-            kind: "refused",
-            refusal: {
-                kind: "invalid-composition",
-                diagnostics: [{ line: 1, reason: "task world has no valid planning coordinate", token: "--plan" }],
-            },
-        };
-    }
     if (command.action === "namespace")
         return { kind: "accepted", value: [] };
     if (command.action === "hold" || command.action === "done" || command.action === "drop") {
@@ -348,7 +338,6 @@ async function invokeLocalMutation(tasks, command, input, current) {
                 markdown: await input.readStdin(),
                 namespace: current ?? [],
                 ...(input.actor === undefined ? {} : { actor: input.actor }),
-                ...(command.flags.plan === true ? { plan: true } : {}),
             });
         default:
             throw new Error(`task action has no invocation: ${command.action}`);
@@ -356,19 +345,17 @@ async function invokeLocalMutation(tasks, command, input, current) {
 }
 function establishesWorld(command) {
     return (command.action === "add" ||
-        (command.action === "compose" && command.flags.plan !== true) ||
+        command.action === "compose" ||
         (command.action === "namespace" && command.positionals.length > 0));
 }
 function forwardsMutation(command) {
     return (command.action !== "show" &&
         command.action !== "tree" &&
         command.action !== "namespace" &&
-        !(command.action === "compose" && command.flags.plan === true) &&
         !isWorldObservation(command));
 }
 export async function invokeTask(command, input) {
-    const planOnly = command.action === "compose" && command.flags.plan === true;
-    const world = input.world ?? (planOnly ? input.candidate : establishesWorld(command) ? await input.establish() : null);
+    const world = input.world ?? (establishesWorld(command) ? await input.establish() : null);
     if (world === null)
         return missingWorld(command);
     const tasks = Tasks.of(world);

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

@@ -133,27 +133,9 @@ task add [--namespace <ns>] [--actor <actor>] -`,
     compose: {
         arity: [0, 0],
         stdin: "compose",
-        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"),
+        flags: { ...COMMON, actor: "value" },
+        usage: "task compose [--actor <actor>] -",
+        purpose: "Admit Task documents independently; partial admission has no cross-file atomicity or rollback.",
     },
 };
 export function isTaskAction(value) {

package/build/src/cli/invoke.js

@@ -318,7 +318,6 @@ 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,9 +59,6 @@ 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) {
@@ -76,9 +73,6 @@ 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) {
@@ -262,30 +256,12 @@ 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`, ...aliasLines(result.aliases)];
+    const lines = [`✓ compose accepted · ${result.documentChanges.length} changed`];
     composeDiffs(lines, result.documentChanges);
     return lines.join("\n");
 }

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

@@ -1,30 +1,18 @@
+import { type TaskId } from "./identity.js";
 import type { WorldRoot } from "../world.js";
-import { type TaskCompositionAlias, type TaskCompositionBodyPreview } from "./compose-language.js";
-import type { TaskId } from "./identity.js";
-import type { TaskRefusal, TaskRetry } from "./operations.js";
-export type TaskDocumentChange = Readonly<{
+import { type TaskRefusal, type TaskRetry } from "./operations.js";
+type TaskDocumentChange = Readonly<{
     taskId: TaskId;
     kind: "created" | "updated";
     documentDiff: string;
 }>;
-export type TaskCompositionFacts = Readonly<{
-    aliases: readonly TaskCompositionAlias[];
-    admissionOrder: readonly TaskId[];
-}>;
 export type TaskCompositionResult = Readonly<{
-    kind: "planned";
-    aliases: readonly TaskCompositionAlias[];
-    admissionOrder: readonly TaskId[];
-    bodies: readonly TaskCompositionBodyPreview[];
-}> | Readonly<{
     kind: "accepted";
     documentChanges: readonly TaskDocumentChange[];
-} & TaskCompositionFacts> | Readonly<{
+}> | Readonly<{
     kind: "refused";
-    refusal: Extract<TaskRefusal, {
-        kind: "invalid-composition";
-    }>;
-}> | (Readonly<{
+    refusal: TaskRefusal;
+}> | Readonly<{
     kind: "incomplete";
     documentChanges: readonly TaskDocumentChange[];
     stopped: TaskRefusal | Readonly<{
@@ -32,5 +20,6 @@ export type TaskCompositionResult = Readonly<{
         reason: TaskRetry;
     }>;
     draft: string;
-}> & TaskCompositionFacts);
-export declare function composeTasks(world: WorldRoot, markdown: string, signal?: AbortSignal, actor?: string, defaultNamespace?: readonly string[], planOnly?: boolean): Promise<TaskCompositionResult>;
+}>;
+export declare function composeTasks(world: WorldRoot, markdown: string, signal?: AbortSignal, actor?: string, defaultNamespace?: readonly string[]): Promise<TaskCompositionResult>;
+export {};

package/build/src/task/compose.js

@@ -1,142 +1,305 @@
 import { documentDiff } from "../markdown/diff.js";
-import { planTaskComposition, } from "./compose-language.js";
+import { relationProblem } from "./board.js";
 import { serializeTaskDocument } from "./document.js";
+import { allocateLocalId, deriveLocalStem, formatTaskId, parseTaskId, sameNamespace } from "./identity.js";
 import { authorityPath, readBoard, replaceAuthority, withTaskLocks } from "./store.js";
-function refusal(diagnostics) {
-    return { kind: "refused", refusal: { kind: "invalid-composition", diagnostics } };
+import { advanceTaskTimestamp } from "./operations.js";
+function failure(diagnostic) {
+    return { kind: "invalid-composition", diagnostic };
 }
-function currentTimestamp() {
-    return new Date().toISOString();
+function parseNamespace(value) {
+    if (value === "")
+        return [];
+    const coordinate = parseTaskId(`task/${value}/placeholder`);
+    return coordinate.namespace;
 }
-function facts(plan) {
-    return { aliases: plan.aliases, admissionOrder: plan.admissionOrder };
-}
-function reference(id, remainingAliases) {
-    const alias = remainingAliases.get(id);
-    return alias === undefined ? `@${id}` : `^${alias}`;
-}
-function bodyToken(body) {
-    const lines = new Set(body.split(/\r\n|\n|\r/u));
-    for (let suffix = 0; Number.isSafeInteger(suffix); suffix += 1) {
-        const token = suffix === 0 ? "END_BODY" : `END_BODY_${suffix}`;
-        if (token.length > 32)
-            break;
-        if (!lines.has(token))
-            return token;
-    }
-    throw new Error("compose recovery body token space exhausted");
-}
-function taskDraft(task, remainingAliases) {
-    const document = task.after;
-    const lines = [task.kind === "new" ? `+ ${document.title}` : `@${document.id}`];
-    if (task.kind === "new" && task.alias !== undefined)
-        lines.push(`as = ${task.alias}`);
-    lines.push(`pri = ${document.priority}`, `needs = ${document.needs.map((id) => reference(id, remainingAliases)).join(", ")}`, `parent = ${document.parent === null ? "" : reference(document.parent, remainingAliases)}`, `supersedes = ${document.supersedes.map((id) => reference(id, remainingAliases)).join(", ")}`, `relates = ${document.relates.map((id) => reference(id, remainingAliases)).join(", ")}`);
-    if (document.body === "")
-        lines.push("body =");
-    else {
-        const token = bodyToken(document.body);
-        lines.push(`body <<${token}`, document.body, token);
-    }
-    return lines;
+function assignment(token) {
+    const matched = /^(parent|needs|supersedes|relates|pri|body)(\+=|=)(.*)$/u.exec(token);
+    if (matched === null)
+        return null;
+    const field = matched[1], append = matched[2] === "+=", value = matched[3];
+    if (append && (field === "parent" || field === "pri" || field === "body"))
+        throw new TypeError(`${field} does not accept +=`);
+    if (field === "body" && (append || value !== ""))
+        throw new TypeError("body accepts only bare body=");
+    return { field, append, value };
 }
-function recoveryDraft(namespace, remaining) {
-    const aliases = new Map();
-    for (const task of remaining) {
-        if (task.kind === "new" && task.alias !== undefined)
-            aliases.set(task.after.id, task.alias);
+function parseNode(text, depth, index) {
+    const tokens = text.split(/ +/u);
+    if (text.startsWith("+ ")) {
+        const values = tokens.slice(1);
+        const at = values.findIndex((token) => assignment(token) !== null);
+        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}`);
+                })()),
+        };
     }
-    const lines = [`ns=${namespace.join("/")}`];
-    for (const task of remaining)
-        lines.push("", ...taskDraft(task, aliases));
-    return `${lines.join("\n")}\n`;
+    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}`);
+            })()),
+    };
 }
-function plannedResult(plan) {
-    return { kind: "planned", ...facts(plan), bodies: plan.bodies };
-}
-function planAgainst(markdown, board, namespace, at, actor) {
-    return planTaskComposition({ markdown, board, namespace, at, ...(actor === undefined ? {} : { actor }) });
-}
-async function admitPlan(world, snapshot, plan, signal) {
-    const changes = [];
-    for (let index = 0; index < plan.tasks.length; index += 1) {
-        signal?.throwIfAborted();
-        const item = plan.tasks[index];
-        const beforeBytes = item.before === null ? null : (snapshot.bytes.get(item.after.id) ?? null);
-        const afterBytes = serializeTaskDocument(item.after);
-        const before = beforeBytes === null ? "" : Buffer.from(beforeBytes).toString("utf8");
-        const after = Buffer.from(afterBytes).toString("utf8");
-        const replaced = await replaceAuthority({
-            path: authorityPath(world, item.after.id),
-            expected: beforeBytes,
-            next: afterBytes,
-        });
-        if (replaced !== "replaced") {
-            return {
-                kind: "incomplete",
-                ...facts(plan),
-                documentChanges: changes,
-                stopped: { kind: "retry", reason: "concurrent-modification" },
-                draft: recoveryDraft(plan.namespace, plan.tasks.slice(index)),
-            };
+function parseSketch(markdown) {
+    try {
+        const lines = markdown.replace(/\r\n?/gu, "\n").split("\n");
+        let namespace;
+        let start = 0;
+        if (lines[0]?.startsWith("ns=")) {
+            namespace = parseNamespace(lines[0].slice(3));
+            start = 1;
+        }
+        const mutable = [];
+        for (let line = start; line < lines.length; line += 1) {
+            const raw = lines[line];
+            if (line === lines.length - 1 && raw === "")
+                continue;
+            const leading = /^(?:\t| )*/u.exec(raw)[0].replace(/\t/gu, "  ");
+            const text = raw.slice(/^(?:\t| )*/u.exec(raw)[0].length);
+            const nodeLine = text.startsWith("+ ") || text.startsWith("@task/");
+            if (nodeLine) {
+                if (leading.length % 2 !== 0)
+                    throw new TypeError(`compose line ${line + 1} has invalid indentation`);
+                const depth = leading.length / 2;
+                if (depth > 0 && !mutable.some((entry) => entry.node.depth === depth - 1))
+                    throw new TypeError(`compose line ${line + 1} skips a parent depth`);
+                mutable.push({ node: parseNode(text, depth, mutable.length), body: [] });
+                continue;
+            }
+            const current = mutable.at(-1);
+            if (current === undefined) {
+                if (text.trim() === "")
+                    continue;
+                throw new TypeError(`compose line ${line + 1} has body before a node`);
+            }
+            current.body.push(text.startsWith("\\") ? text.slice(1) : text);
         }
-        const label = `${item.after.id}.md`;
-        changes.push({
-            taskId: item.after.id,
-            kind: item.before === null ? "created" : "updated",
-            documentDiff: documentDiff(label, label, before, after),
-        });
+        const nodes = mutable.map(({ node, body }) => ({
+            ...node,
+            ...(body.length === 0 ? {} : { body: body.join("\n") }),
+        }));
+        return { ...(namespace === undefined ? {} : { namespace }), nodes };
     }
-    return { kind: "accepted", ...facts(plan), documentChanges: changes };
-}
-async function composeUnderLocks(input) {
-    const snapshot = await readBoard(input.world);
-    const planned = planAgainst(input.markdown, snapshot.board, input.namespace, input.at, input.actor);
-    if (planned.kind === "refused")
-        return refusal(planned.diagnostics);
-    return await withTaskLocks({
-        world: input.world,
-        allocation: false,
-        ids: planned.plan.admissionOrder,
-        ...(input.signal === undefined ? {} : { signal: input.signal }),
-    }, async () => {
-        const fresh = await readBoard(input.world);
-        const replanned = planAgainst(input.markdown, fresh.board, input.namespace, input.at, input.actor);
-        if (replanned.kind === "refused")
-            return refusal(replanned.diagnostics);
-        return await admitPlan(input.world, fresh, replanned.plan, input.signal);
+    catch (error) {
+        return failure(error instanceof Error ? error.message : String(error));
+    }
+}
+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;
     });
+    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 composeInput(world, markdown, namespace, at, actor, signal) {
+function changed(current, value, append) {
+    return append ? [...current, ...value.filter((id) => !current.includes(id))] : value;
+}
+function applyAssignments(document, assignments, body) {
+    let next = document;
+    const seen = new Set();
+    for (const item of assignments) {
+        const mode = `${item.field}:${item.append}`;
+        if (seen.has(mode) || [...seen].some((value) => value.startsWith(`${item.field}:`) && value !== mode))
+            throw new TypeError(`duplicate compose assignment: ${item.field}`);
+        seen.add(mode);
+        if (item.field === "pri") {
+            const priority = Number(item.value);
+            if (!Number.isInteger(priority) || priority < 0 || priority > 3)
+                throw new TypeError("pri must be 0..3");
+            next = { ...next, priority: priority };
+        }
+        else if (item.field === "parent")
+            next = { ...next, parent: scalarId(item.value) };
+        else if (item.field === "body")
+            next = { ...next, body: "" };
+        else
+            next = { ...next, [item.field]: changed(next[item.field], ids(item.value), item.append) };
+    }
+    return body === undefined ? next : { ...next, body };
+}
+function currentTimestamp() {
+    return new Date().toISOString();
+}
+function createdTask(id, title, at, actor) {
     return {
-        world,
-        markdown,
-        namespace,
-        at,
-        ...(actor === undefined ? {} : { actor }),
-        ...(signal === undefined ? {} : { signal }),
+        id,
+        title,
+        state: "open",
+        priority: 2,
+        needs: [],
+        parent: null,
+        supersedes: [],
+        relates: [],
+        note: "",
+        ...(actor === undefined ? {} : { createdBy: actor }),
+        createdAt: at,
+        updatedAt: at,
+        body: "",
     };
 }
-export async function composeTasks(world, markdown, signal, actor, defaultNamespace = [], planOnly = false) {
+function plan(sketch, board, defaultNamespace, at, actor) {
+    try {
+        const namespace = sketch.namespace ?? defaultNamespace;
+        const occupied = new Set([...board.tasks.values()].flatMap((task) => {
+            const coordinate = parseTaskId(task.id);
+            return sameNamespace(coordinate.namespace, namespace) ? [coordinate.localId] : [];
+        }));
+        const allocations = new Map();
+        for (const node of sketch.nodes)
+            if (node.kind === "new") {
+                const localId = allocateLocalId(deriveLocalStem(node.title), occupied);
+                occupied.add(localId);
+                const coordinate = { namespace, localId };
+                allocations.set(node.index, createdTask(formatTaskId(coordinate), node.title, at, actor));
+            }
+        const all = new Map(board.tasks);
+        for (const allocated of allocations.values())
+            all.set(allocated.id, allocated);
+        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);
+            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}`);
+            if (addressed.has(current.id))
+                throw new TypeError(`compose addresses ${current.id} more than once`);
+            addressed.add(current.id);
+            if (node.depth > 0) {
+                const parent = byDepth[node.depth - 1];
+                if (parent === undefined)
+                    throw new TypeError("compose parent is unavailable");
+                if (node.assignments.some((item) => item.field === "parent"))
+                    throw new TypeError("indented node cannot also assign parent");
+                current = { ...current, parent };
+            }
+            current = applyAssignments(current, node.assignments, node.body);
+            if (before !== null &&
+                !Buffer.from(serializeTaskDocument(current)).equals(Buffer.from(serializeTaskDocument(before)))) {
+                current = {
+                    ...current,
+                    updatedAt: advanceTaskTimestamp(before.updatedAt, at),
+                };
+            }
+            byDepth[node.depth] = current.id;
+            byDepth.length = node.depth + 1;
+            all.set(current.id, current);
+            planned.push({ node, before, after: current });
+        }
+        for (const item of planned) {
+            const problem = relationProblem({ tasks: all }, item.before, item.after);
+            if (problem !== null)
+                return failure(problem);
+        }
+        return planned;
+    }
+    catch (error) {
+        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 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(",")}`,
+        ];
+        lines.push(`${item.node.kind === "new" ? `+ ${task.title}` : ref(task.id)} ${assignments.join(" ")}${task.body === "" ? " body=" : ""}`);
+        if (task.body !== "")
+            lines.push(...bodyLines(task.body));
+    }
+    return `${lines.join("\n")}\n`;
+}
+export async function composeTasks(world, markdown, signal, actor, defaultNamespace) {
+    const sketch = parseSketch(markdown);
+    if ("kind" in sketch)
+        return { kind: "refused", refusal: sketch };
     const at = currentTimestamp();
+    const namespace = sketch.namespace ?? defaultNamespace ?? [];
     const initial = await readBoard(world);
-    const initialPlan = planAgainst(markdown, initial.board, defaultNamespace, at, actor);
-    if (initialPlan.kind === "refused")
-        return refusal(initialPlan.diagnostics);
-    if (planOnly)
-        return plannedResult(initialPlan.plan);
-    const input = composeInput(world, markdown, defaultNamespace, at, actor, signal);
-    const allocation = initialPlan.plan.tasks.some((task) => task.kind === "new");
-    const admitted = allocation
-        ? await withTaskLocks({ world, allocation: true, ids: [], ...(signal === undefined ? {} : { signal }) }, async () => await composeUnderLocks(input))
-        : await composeUnderLocks(input);
-    if (admitted !== "busy")
-        return admitted;
-    return {
-        kind: "incomplete",
-        ...facts(initialPlan.plan),
-        documentChanges: [],
-        stopped: { kind: "retry", reason: "busy" },
-        draft: recoveryDraft(initialPlan.plan.namespace, initialPlan.plan.tasks),
-    };
+    const planned = plan(sketch, initial.board, namespace, at, actor);
+    if ("kind" in planned)
+        return { kind: "refused", refusal: planned };
+    const ordered = [...planned].sort((a, b) => Buffer.compare(Buffer.from(a.after.id), Buffer.from(b.after.id)));
+    const allocation = sketch.nodes.some((node) => node.kind === "new");
+    const result = await withTaskLocks({ world, allocation, ids: ordered.map((item) => item.after.id), ...(signal === undefined ? {} : { signal }) }, async () => {
+        const fresh = await readBoard(world);
+        const replanned = plan(sketch, fresh.board, namespace, at, actor);
+        if ("kind" in replanned)
+            return { kind: "refused", refusal: replanned };
+        const queue = [...replanned].sort((a, b) => Buffer.compare(Buffer.from(a.after.id), Buffer.from(b.after.id))), changes = [];
+        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 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")
+                return {
+                    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),
+            });
+        }
+        return { kind: "accepted", documentChanges: changes };
+    });
+    return result === "busy"
+        ? {
+            kind: "incomplete",
+            documentChanges: [],
+            stopped: { kind: "retry", reason: "busy" },
+            draft: draft(namespace, ordered),
+        }
+        : result;
 }

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

@@ -4,7 +4,7 @@ import { type BlockedTaskRow, type TaskDetailFacts, type TaskDoctorIssue, type T
 import { type TaskCompositionResult } from "./compose.js";
 import { TaskAuthorityCorruptionError, type TaskPriority, type TaskState } from "./document.js";
 import type { TaskId } from "./identity.js";
-import { type AddTaskDocumentInput, type AddTaskInput, type TaskBatchResult, type TaskCompositionDiagnostic, type TaskMutationResult, type TaskOutcome, type TaskRefusal, type TaskRetry, type TaskUpdateResult, type TaskView, type UpdateTaskInput } from "./operations.js";
+import { type AddTaskDocumentInput, type AddTaskInput, type TaskBatchResult, type TaskMutationResult, type TaskOutcome, type TaskRefusal, type TaskRetry, type TaskUpdateResult, type TaskView, type UpdateTaskInput } from "./operations.js";
 import { TASK_RELATION_PREDICATE_FIELDS, type TaskPage, type TaskQueryExpression, type TaskQueryPredicate, type TaskQueryRow, type TaskQuerySort, type TaskRelationPredicateField } from "./query.js";
 export type TaskDetail = Omit<TaskDetailFacts, "task"> & Readonly<{
     task: TaskView;
@@ -17,7 +17,7 @@ export type TaskDoctorReport = Readonly<{
     issues: readonly TaskDoctorIssue[];
 }>;
 export type TaskDecompositionTree = TaskOutcome<TaskTreeNode>;
-export type { AddTaskDocumentInput, AddTaskInput, BlockedTaskRow, TaskBatchResult, TaskCompositionDiagnostic, TaskCompositionResult, TaskDoctorIssue, TaskId, TaskMutationResult, TaskOutcome, TaskPriority, TaskRef, TaskRefusal, TaskRetry, TaskRow, TaskState, TaskTreeNode, TaskUpdateResult, TaskView, UpdateTaskInput, TaskPage, TaskQueryExpression, TaskQueryPredicate, TaskQueryRow, TaskQuerySort, TaskRelationPredicateField, };
+export type { AddTaskDocumentInput, AddTaskInput, BlockedTaskRow, TaskBatchResult, TaskCompositionResult, TaskDoctorIssue, TaskId, TaskMutationResult, TaskOutcome, TaskPriority, TaskRef, TaskRefusal, TaskRetry, TaskRow, TaskState, TaskTreeNode, TaskUpdateResult, TaskView, UpdateTaskInput, TaskPage, TaskQueryExpression, TaskQueryPredicate, TaskQueryRow, TaskQuerySort, TaskRelationPredicateField, };
 export { TaskAuthorityCorruptionError, TASK_RELATION_PREDICATE_FIELDS };
 declare class TaskHandle {
     readonly id: TaskId;
@@ -95,7 +95,6 @@ declare class TasksHandle {
         namespace?: readonly string[];
         actor?: string;
         signal?: AbortSignal;
-        plan?: boolean;
     }>): Promise<TaskCompositionResult>;
 }
 export type Tasks = TasksHandle;

package/build/src/task/index.js

@@ -149,14 +149,12 @@ class TasksHandle {
     }
     compose(input) {
         const v = record(input, "compose input");
-        closed(v, ["markdown", "namespace", "actor", "signal", "plan"], "compose input");
+        closed(v, ["markdown", "namespace", "actor", "signal"], "compose input");
         const markdown = text(v.markdown, "markdown");
         if (markdown === undefined)
             throw new TypeError("markdown is required");
-        if (v.plan !== undefined && typeof v.plan !== "boolean")
-            throw new TypeError("plan must be a boolean");
         const selected = namespace(v.namespace);
-        return composeTasks(this.world, markdown, signal(v.signal), actor(v.actor), selected, v.plan === true);
+        return composeTasks(this.world, markdown, signal(v.signal), actor(v.actor), selected);
     }
 }
 export const Tasks = Object.freeze({

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

@@ -9,11 +9,6 @@ export type TaskView = Readonly<TaskDocument & {
 export declare function nukeTask(world: WorldRoot, options?: Readonly<{
     timeoutMs?: number;
 }>): Promise<void>;
-export type TaskCompositionDiagnostic = Readonly<{
-    line: number;
-    reason: string;
-    token: string;
-}>;
 export type TaskRefusal = Readonly<{
     kind: "task-missing";
     taskId: TaskId;
@@ -35,7 +30,7 @@ export type TaskRefusal = Readonly<{
     declaringTask: TaskId;
 }> | Readonly<{
     kind: "invalid-composition";
-    diagnostics: readonly TaskCompositionDiagnostic[];
+    diagnostic: string;
 }>;
 export type TaskRetry = "busy" | "concurrent-modification";
 export type TaskOutcome<A> = Readonly<{

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@astrosheep/keiyaku",
-  "version": "4.5.4",
+  "version": "4.5.5",
   "files": [
     "build"
   ],

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

@@ -1,43 +0,0 @@
-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 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;

package/build/src/task/compose-language.js

@@ -1,314 +0,0 @@
-import { serializeTaskDocument } from "./document.js";
-import { allocateLocalId, deriveLocalStem, formatTaskId, parseTaskId, sameNamespace } from "./identity.js";
-import { parseTaskComposition } from "./compose-parser.js";
-import { advanceTaskTimestamp } from "./operations.js";
-function diagnostic(line, reason, token) {
-    return { line, reason, token };
-}
-function occupied(board, namespace) {
-    return new Set([...board.tasks.values()].flatMap((task) => {
-        const coordinate = parseTaskId(task.id);
-        return sameNamespace(coordinate.namespace, namespace) ? [coordinate.localId] : [];
-    }));
-}
-function createdTask(id, title, at, actor) {
-    return {
-        id,
-        title,
-        state: "open",
-        priority: 2,
-        needs: [],
-        parent: null,
-        supersedes: [],
-        relates: [],
-        note: "",
-        ...(actor === undefined ? {} : { createdBy: actor }),
-        createdAt: at,
-        updatedAt: at,
-        body: "",
-    };
-}
-function aliasFor(node) {
-    return node.assignments.find((item) => item.field === "as");
-}
-function allocateNodes(parsed, board, namespace, at, actor, diagnostics) {
-    const ids = occupied(board, namespace);
-    const allocations = new Map();
-    for (const node of parsed.nodes) {
-        if (node.kind !== "new")
-            continue;
-        try {
-            const localId = allocateLocalId(deriveLocalStem(node.title), ids);
-            ids.add(localId);
-            const id = formatTaskId({ namespace, localId });
-            allocations.set(node.index, createdTask(id, node.title, at, actor));
-        }
-        catch (error) {
-            diagnostics.push(diagnostic(node.line, error instanceof Error ? error.message : String(error), node.title));
-        }
-    }
-    return allocations;
-}
-function collectAliases(nodes, allocations, diagnostics) {
-    const aliases = new Map();
-    for (const node of nodes) {
-        const declarations = node.assignments.filter((item) => item.field === "as");
-        for (const duplicate of declarations.slice(1)) {
-            diagnostics.push(diagnostic(duplicate.line, "alias is assigned more than once", duplicate.token));
-        }
-        const declaration = declarations[0];
-        if (declaration === undefined)
-            continue;
-        if (node.kind !== "new") {
-            diagnostics.push(diagnostic(declaration.line, "only a new task may declare an alias", declaration.token));
-            continue;
-        }
-        if (declaration.operator !== "=" || !/^[a-z0-9-]+$/u.test(declaration.value)) {
-            diagnostics.push(diagnostic(declaration.line, "alias must use as = [a-z0-9-]+", declaration.token));
-            continue;
-        }
-        if (aliases.has(declaration.value)) {
-            diagnostics.push(diagnostic(declaration.line, "alias must be unique in the composition", declaration.value));
-            continue;
-        }
-        const allocated = allocations.get(node.index);
-        if (allocated !== undefined)
-            aliases.set(declaration.value, allocated.id);
-    }
-    return aliases;
-}
-function resolveReference(raw, line, board, aliases, diagnostics) {
-    if (raw.startsWith("^")) {
-        const alias = raw.slice(1);
-        const resolved = aliases.get(alias);
-        if (resolved === undefined)
-            diagnostics.push(diagnostic(line, "new-task alias is not declared", raw));
-        return resolved;
-    }
-    if (!raw.startsWith("@task/")) {
-        diagnostics.push(diagnostic(line, "reference must be @task/... or ^alias", raw));
-        return undefined;
-    }
-    try {
-        const id = raw.slice(1);
-        parseTaskId(id);
-        if (!board.tasks.has(id))
-            diagnostics.push(diagnostic(line, "@ reference must name a pre-existing task", raw));
-        return board.tasks.has(id) ? id : undefined;
-    }
-    catch (error) {
-        diagnostics.push(diagnostic(line, error instanceof Error ? error.message : String(error), raw));
-        return undefined;
-    }
-}
-function referenceList(assignment, board, aliases, diagnostics) {
-    if (assignment.value === "")
-        return [];
-    const raw = assignment.value.split(",").map((item) => item.trim());
-    if (raw.some((item) => item.length === 0)) {
-        diagnostics.push(diagnostic(assignment.line, "reference list contains an empty item", assignment.token));
-        return undefined;
-    }
-    const resolved = raw.map((item) => resolveReference(item, assignment.line, board, aliases, diagnostics));
-    if (resolved.some((item) => item === undefined))
-        return undefined;
-    const ids = resolved;
-    if (new Set(ids).size !== ids.length) {
-        diagnostics.push(diagnostic(assignment.line, "reference list contains a duplicate", assignment.token));
-        return undefined;
-    }
-    return ids;
-}
-function patchRelation(current, assignment, values, diagnostics) {
-    if (assignment.operator === "=")
-        return values;
-    if (assignment.operator === "+=")
-        return [...current, ...values.filter((id) => !current.includes(id))];
-    const missing = values.filter((id) => !current.includes(id));
-    for (const id of missing)
-        diagnostics.push(diagnostic(assignment.line, "cannot remove an absent relation", `@${id}`));
-    return missing.length === 0 ? current.filter((id) => !values.includes(id)) : current;
-}
-function applyAssignments(node, base, board, aliases, diagnostics) {
-    let next = base;
-    const scalar = new Set();
-    for (const assignment of node.assignments) {
-        if (assignment.field === "as")
-            continue;
-        if (assignment.field === "pri" || assignment.field === "parent") {
-            if (scalar.has(assignment.field)) {
-                diagnostics.push(diagnostic(assignment.line, `${assignment.field} is assigned more than once`, assignment.token));
-            }
-            scalar.add(assignment.field);
-        }
-        if (assignment.field === "pri") {
-            if (assignment.operator !== "=" || !/^[0-3]$/u.test(assignment.value)) {
-                diagnostics.push(diagnostic(assignment.line, "pri must use = with a value from 0 through 3", assignment.token));
-            }
-            else
-                next = { ...next, priority: Number(assignment.value) };
-            continue;
-        }
-        if (assignment.field === "parent") {
-            if (assignment.operator !== "=") {
-                diagnostics.push(diagnostic(assignment.line, "parent accepts only =", assignment.token));
-            }
-            else if (assignment.value === "")
-                next = { ...next, parent: null };
-            else {
-                const id = resolveReference(assignment.value.trim(), assignment.line, board, aliases, diagnostics);
-                if (id !== undefined)
-                    next = { ...next, parent: id };
-            }
-            continue;
-        }
-        const values = referenceList(assignment, board, aliases, diagnostics);
-        if (values === undefined)
-            continue;
-        if (assignment.operator !== "=" && values.length === 0) {
-            diagnostics.push(diagnostic(assignment.line, `${assignment.operator} requires at least one reference`, assignment.token));
-            continue;
-        }
-        next = { ...next, [assignment.field]: patchRelation(next[assignment.field], assignment, values, diagnostics) };
-    }
-    if (node.body !== undefined)
-        next = { ...next, body: node.body.value };
-    for (const field of ["needs", "supersedes", "relates"]) {
-        if (next[field].includes(next.id))
-            diagnostics.push(diagnostic(node.line, `${field} cannot reference the task itself`, next.id));
-    }
-    if (next.parent === next.id)
-        diagnostics.push(diagnostic(node.line, "parent cannot reference the task itself", next.id));
-    return next;
-}
-function relationTargets(document, relation) {
-    return relation === "needs" ? document.needs : document.parent === null ? [] : [document.parent];
-}
-function pathExists(board, start, goal, relation) {
-    const seen = new Set();
-    const pending = [start];
-    while (pending.length > 0) {
-        const id = pending.pop();
-        if (id === goal)
-            return true;
-        if (seen.has(id))
-            continue;
-        seen.add(id);
-        const task = board.tasks.get(id);
-        if (task !== undefined)
-            pending.push(...relationTargets(task, relation));
-    }
-    return false;
-}
-function diagnoseIntroducedCycles(after, tasks, diagnostics) {
-    for (const task of tasks) {
-        for (const relation of ["needs", "parent"]) {
-            const old = task.before === null ? [] : relationTargets(task.before, relation);
-            for (const target of relationTargets(task.after, relation)) {
-                if (!old.includes(target) && pathExists(after, target, task.after.id, relation)) {
-                    diagnostics.push(diagnostic(task.line, `${relation} edge creates a cycle`, `${task.after.id} -> ${target}`));
-                }
-            }
-        }
-    }
-}
-function changed(task) {
-    return (task.before === null ||
-        !Buffer.from(serializeTaskDocument(task.before)).equals(Buffer.from(serializeTaskDocument(task.after))));
-}
-function stableAdmissionOrder(tasks, diagnostics) {
-    const candidates = tasks.filter(changed);
-    const byId = new Map(candidates.map((task) => [task.after.id, task]));
-    const dependencies = new Map(candidates.map((task) => [task.after.id, new Set()]));
-    for (const task of candidates) {
-        const targets = [...task.after.needs, ...(task.after.parent === null ? [] : [task.after.parent])];
-        for (const target of targets) {
-            const plannedTarget = byId.get(target);
-            if (plannedTarget?.before === null)
-                dependencies.get(task.after.id).add(target);
-        }
-    }
-    const remaining = new Set(candidates.map((task) => task.after.id));
-    const ordered = [];
-    while (remaining.size > 0) {
-        const ready = candidates.find((task) => remaining.has(task.after.id) && [...dependencies.get(task.after.id)].every((id) => !remaining.has(id)));
-        if (ready === undefined) {
-            const first = candidates.find((task) => remaining.has(task.after.id));
-            diagnostics.push(diagnostic(first.line, "needs and parent references create an admission cycle", first.after.id));
-            return [];
-        }
-        remaining.delete(ready.after.id);
-        ordered.push(ready);
-    }
-    return ordered;
-}
-function bodyPreview(node, id) {
-    if (node.body?.kind !== "replace")
-        return null;
-    const lines = node.body.value.split(/\r\n|\n|\r/u);
-    return {
-        taskId: id,
-        bytes: Buffer.byteLength(node.body.value),
-        firstLine: lines[0] ?? "",
-        lastLine: lines.at(-1) ?? "",
-    };
-}
-export function planTaskComposition(input) {
-    const parsed = parseTaskComposition(input.markdown);
-    const diagnostics = [...parsed.diagnostics];
-    const namespace = parsed.namespace ?? input.namespace;
-    const allocations = allocateNodes(parsed, input.board, namespace, input.at, input.actor, diagnostics);
-    const aliases = collectAliases(parsed.nodes, allocations, diagnostics);
-    const addressed = new Set();
-    const tasks = [];
-    for (const node of parsed.nodes) {
-        const before = node.kind === "new" ? null : (input.board.tasks.get(node.id) ?? null);
-        const base = node.kind === "new" ? allocations.get(node.index) : before;
-        if (base === null || base === undefined) {
-            diagnostics.push(diagnostic(node.line, "existing task does not exist before composition", `@${node.id}`));
-            continue;
-        }
-        if (addressed.has(base.id)) {
-            diagnostics.push(diagnostic(node.line, "task is addressed more than once", base.id));
-            continue;
-        }
-        addressed.add(base.id);
-        let after = applyAssignments(node, base, input.board, aliases, diagnostics);
-        if (before !== null && changed({ index: node.index, line: node.line, kind: node.kind, before, after })) {
-            after = { ...after, updatedAt: advanceTaskTimestamp(before.updatedAt, input.at) };
-        }
-        tasks.push({
-            index: node.index,
-            line: node.line,
-            kind: node.kind,
-            ...(aliasFor(node) === undefined ? {} : { alias: aliasFor(node).value }),
-            before,
-            after,
-        });
-    }
-    const post = new Map(input.board.tasks);
-    for (const task of tasks)
-        post.set(task.after.id, task.after);
-    diagnoseIntroducedCycles({ tasks: post }, tasks, diagnostics);
-    const ordered = stableAdmissionOrder(tasks, diagnostics);
-    if (diagnostics.length > 0)
-        return { kind: "refused", diagnostics };
-    const aliasBindings = [...aliases].map(([alias, taskId]) => ({ alias, taskId }));
-    const bodies = parsed.nodes.flatMap((node) => {
-        const task = tasks.find((candidate) => candidate.index === node.index);
-        if (task === undefined)
-            return [];
-        const preview = bodyPreview(node, task.after.id);
-        return preview === null ? [] : [preview];
-    });
-    return {
-        kind: "planned",
-        plan: {
-            namespace,
-            aliases: aliasBindings,
-            admissionOrder: ordered.map((task) => task.after.id),
-            bodies,
-            tasks: ordered,
-        },
-    };
-}

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

@@ -1,31 +0,0 @@
-import { type TaskId } from "./identity.js";
-import type { TaskCompositionDiagnostic } from "./operations.js";
-export type RelationField = "needs" | "supersedes" | "relates";
-export type Assignment = Readonly<{
-    field: "as" | "parent" | "pri" | RelationField;
-    operator: "=" | "+=" | "-=";
-    value: string;
-    line: number;
-    token: string;
-}>;
-export type BodyAssignment = Readonly<{
-    kind: "clear" | "replace";
-    value: string;
-    line: number;
-    token: string;
-}>;
-export type ParsedNode = Readonly<{
-    index: number;
-    line: number;
-    kind: "new" | "existing";
-    title?: string;
-    id?: TaskId;
-    assignments: readonly Assignment[];
-    body?: BodyAssignment;
-}>;
-export type ParsedComposition = Readonly<{
-    namespace?: readonly string[];
-    nodes: readonly ParsedNode[];
-    diagnostics: readonly TaskCompositionDiagnostic[];
-}>;
-export declare function parseTaskComposition(source: string): ParsedComposition;

package/build/src/task/compose-parser.js

@@ -1,162 +0,0 @@
-import { parseTaskId } from "./identity.js";
-function diagnostic(line, reason, token) {
-    return { line, reason, token };
-}
-function sourceLines(source) {
-    const lines = [];
-    let start = 0;
-    let number = 1;
-    while (start < source.length) {
-        let cursor = start;
-        while (cursor < source.length && source[cursor] !== "\n" && source[cursor] !== "\r")
-            cursor += 1;
-        let end = cursor;
-        if (source[cursor] === "\r" && source[cursor + 1] === "\n")
-            end += 2;
-        else if (cursor < source.length)
-            end += 1;
-        lines.push({ number, start, end, text: source.slice(start, cursor) });
-        start = end;
-        number += 1;
-    }
-    if (source.length === 0 || source.endsWith("\n") || source.endsWith("\r")) {
-        lines.push({ number, start: source.length, end: source.length, text: "" });
-    }
-    return lines;
-}
-function withoutFenceSeparator(value) {
-    if (value.endsWith("\r\n"))
-        return value.slice(0, -2);
-    if (value.endsWith("\n") || value.endsWith("\r"))
-        return value.slice(0, -1);
-    return value;
-}
-function parseNamespace(value) {
-    if (value === "")
-        return [];
-    return parseTaskId(`task/${value}/placeholder`).namespace;
-}
-function parseAssignment(text, line) {
-    const matched = /^(as|parent|pri|needs|supersedes|relates)\s*(=|\+=|-=)\s*(.*)$/u.exec(text);
-    if (matched === null)
-        return null;
-    return {
-        field: matched[1],
-        operator: matched[2],
-        value: matched[3],
-        line,
-        token: text,
-    };
-}
-function parseNode(text, line, index) {
-    if (text.startsWith("+ ")) {
-        const title = text.slice(2);
-        return title.trim().length === 0
-            ? diagnostic(line, "new task title must be nonblank", text)
-            : { index, line, kind: "new", title, assignments: [] };
-    }
-    if (!text.startsWith("@task/"))
-        return diagnostic(line, "node must begin with + or @task/", text);
-    try {
-        const id = text.slice(1);
-        parseTaskId(id);
-        return { index, line, kind: "existing", id, assignments: [] };
-    }
-    catch (error) {
-        return diagnostic(line, error instanceof Error ? error.message : String(error), text);
-    }
-}
-function withAssignment(node, assignment) {
-    return { ...node, assignments: [...node.assignments, assignment] };
-}
-function withBody(node, body) {
-    return { ...node, body };
-}
-function replaceNode(nodes, node) {
-    nodes[node.index] = node;
-}
-export function parseTaskComposition(source) {
-    const lines = sourceLines(source);
-    const diagnostics = [];
-    const nodes = [];
-    let namespace;
-    let current;
-    let sawNode = false;
-    let sawNamespace = false;
-    for (let index = 0; index < lines.length; index += 1) {
-        const line = lines[index];
-        const text = line.text.trimStart();
-        if (text.trim().length === 0)
-            continue;
-        if (text.startsWith("ns=")) {
-            if (sawNode || sawNamespace)
-                diagnostics.push(diagnostic(line.number, "namespace must be the first nonblank line", text));
-            else {
-                try {
-                    namespace = parseNamespace(text.slice(3));
-                }
-                catch (error) {
-                    diagnostics.push(diagnostic(line.number, error instanceof Error ? error.message : String(error), text));
-                }
-            }
-            sawNamespace = true;
-            continue;
-        }
-        if (text.startsWith("+ ") || text.startsWith("@task/")) {
-            const parsed = parseNode(text, line.number, nodes.length);
-            if ("reason" in parsed) {
-                diagnostics.push(parsed);
-                current = undefined;
-            }
-            else {
-                nodes.push(parsed);
-                current = parsed;
-            }
-            sawNode = true;
-            continue;
-        }
-        if (current === undefined) {
-            diagnostics.push(diagnostic(line.number, "property must follow a task node", text));
-            continue;
-        }
-        const fence = /^body\s+<<(.+)$/u.exec(text);
-        if (fence !== null) {
-            const token = fence[1];
-            if (!/^[A-Z][A-Z0-9_]{2,31}$/u.test(token)) {
-                diagnostics.push(diagnostic(line.number, "body token must match [A-Z][A-Z0-9_]* with length 3..32", token));
-                continue;
-            }
-            const close = lines.findIndex((candidate, candidateIndex) => candidateIndex > index && candidate.text === token);
-            if (close < 0) {
-                diagnostics.push(diagnostic(line.number, "body fence is not closed", token));
-                break;
-            }
-            const body = withoutFenceSeparator(source.slice(line.end, lines[close].start));
-            if (current.body !== undefined)
-                diagnostics.push(diagnostic(line.number, "body is assigned more than once", text));
-            else {
-                current = withBody(current, { kind: "replace", value: body, line: line.number, token });
-                replaceNode(nodes, current);
-            }
-            index = close;
-            continue;
-        }
-        if (/^body\s*=\s*$/u.test(text)) {
-            if (current.body !== undefined)
-                diagnostics.push(diagnostic(line.number, "body is assigned more than once", text));
-            else {
-                current = withBody(current, { kind: "clear", value: "", line: line.number, token: text });
-                replaceNode(nodes, current);
-            }
-            continue;
-        }
-        const assignment = parseAssignment(text, line.number);
-        if (assignment === null)
-            diagnostics.push(diagnostic(line.number, "unknown compose property", text));
-        else {
-            current = withAssignment(current, assignment);
-            replaceNode(nodes, current);
-        }
-    }
-    return { ...(namespace === undefined ? {} : { namespace }), nodes, diagnostics };
-}