@astrosheep/keiyaku 4.5.29 → 4.6.2

package/build/src/settings.js

@@ -1,7 +1,6 @@
 import { readFile, realpath } from "node:fs/promises";
 import { homedir } from "node:os";
 import { join, resolve } from "node:path";
-import { gateWord } from "./core/facts/types.js";
 export class SettingsError extends Error {
     kind = "settings";
     constructor(message) {
@@ -129,78 +128,3 @@ export async function projectSettings(root) {
         state: { kind: "absent" },
     });
 }
-function namespaceFailure(view) {
-    if (view.kind !== "failed")
-        throw new Error("settings namespace failure expected");
-    throw new SettingsError(view.failures.map((failure) => `${failure.scope}: ${failure.diagnostic}`).join("; "));
-}
-function bundleGates(name, value) {
-    if (!object(value))
-        throw new SettingsError(`gate bundle '${name}' must be an object`);
-    if (value.kind !== "bundle") {
-        throw new SettingsError(`gate bundle '${name}' has unsupported kind: ${String(value.kind)}`);
-    }
-    for (const field of Object.keys(value)) {
-        if (field !== "kind" && field !== "gates") {
-            throw new SettingsError(`gate bundle '${name}' has unknown field: ${field}`);
-        }
-    }
-    if (!Array.isArray(value.gates)) {
-        throw new SettingsError(`gate bundle '${name}'.gates must be an array`);
-    }
-    return value.gates.map((gate) => {
-        if (!gateWord(gate)) {
-            throw new SettingsError(`gate bundle '${name}' contains an invalid gate word`);
-        }
-        return gate;
-    });
-}
-export function gatesFrom(input) {
-    if (!object(input))
-        throw new TypeError("gatesFrom input must be an object");
-    if (input.names !== undefined && !Array.isArray(input.names)) {
-        throw new TypeError("gatesFrom names must be an array");
-    }
-    const names = input.names ?? ["default"];
-    for (const name of names) {
-        if (!gateWord(name))
-            throw new SettingsError("gate or bundle name must match ^[a-z][a-z0-9-]{0,63}$");
-    }
-    if (names.length === 0)
-        return Object.freeze([]);
-    const view = input.settings.namespace("gates");
-    if (view.kind === "failed")
-        namespaceFailure(view);
-    const expanded = [];
-    const seen = new Set();
-    for (const name of names) {
-        const selected = view.entries.find((entry) => entry.name === name);
-        const gates = selected === undefined ? [input.names === undefined ? "reviewed" : name] : bundleGates(name, selected.value);
-        for (const gate of gates) {
-            if (seen.has(gate))
-                continue;
-            seen.add(gate);
-            expanded.push(gate);
-        }
-    }
-    return Object.freeze(expanded);
-}
-export function requireBranchesToBeUpToDateFrom(input) {
-    if (!object(input))
-        throw new TypeError("requireBranchesToBeUpToDateFrom input must be an object");
-    const view = input.settings.namespace("git");
-    if (view.kind === "failed")
-        namespaceFailure(view);
-    for (const entry of view.entries) {
-        if (entry.name !== "requireBranchesToBeUpToDate") {
-            throw new SettingsError(`git has unknown entry: ${entry.name}`);
-        }
-    }
-    const selected = view.entries.find((entry) => entry.name === "requireBranchesToBeUpToDate");
-    if (selected === undefined)
-        return false;
-    if (typeof selected.value !== "boolean") {
-        throw new SettingsError("git.requireBranchesToBeUpToDate must be a boolean");
-    }
-    return selected.value;
-}

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

@@ -17,7 +17,7 @@ export declare function claimTaskHolder(taskId: TaskId, owner: ContractId): Tree
 type AdmissionOutcome = Readonly<{
     kind: string;
 }>;
-export type TaskHolderAdmission<T extends AdmissionOutcome> = Readonly<{
+type TaskHolderAdmission<T extends AdmissionOutcome> = Readonly<{
     kind: "completed";
     result: T;
 }> | Readonly<{

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

@@ -1,33 +1,41 @@
+import { z } from "zod";
 import { type ContractId, type ContractState } from "../core/facts/types.js";
 import { type PrivateStateSeatCloseLag } from "../git/private-state-seat.js";
 import type { GitDecodeChannel } from "../git/read-observation.js";
 import type { Effect } from "../git/reconcile.js";
-import type { GitRepository } from "../git/process.js";
-import { type TaskId } from "../task/identity.js";
-export { decodeSettlementLag } from "./result-codec.js";
-export type SettlementAction = Readonly<{
-    kind: "task";
-    taskId: TaskId;
-    action: "done";
-}>;
-export type SettlementLag = Readonly<{
-    kind: "settlement-failed";
-    surface: "task-holder" | "task";
-    contractId: ContractId;
-    taskId?: TaskId;
-    path?: string;
-    diagnostic: string;
-}>;
+import { type GitRepository } from "../git/process.js";
+export declare const settlementActionSchema: z.ZodObject<{
+    kind: z.ZodLiteral<"task">;
+    taskId: z.ZodPipe<z.ZodString, z.ZodTransform<`task/${string}`, string>>;
+    action: z.ZodLiteral<"done">;
+}, z.core.$strict>;
+export type SettlementAction = z.infer<typeof settlementActionSchema>;
+export declare const settlementLagSchema: z.ZodObject<{
+    kind: z.ZodLiteral<"settlement-failed">;
+    surface: z.ZodEnum<{
+        task: "task";
+        "task-holder": "task-holder";
+    }>;
+    contractId: z.ZodPipe<z.ZodString, z.ZodTransform<ContractId, string>>;
+    taskId: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<`task/${string}`, string>>>;
+    path: z.ZodOptional<z.ZodString>;
+    diagnostic: z.ZodString;
+}, z.core.$strict>;
+export type SettlementLag = z.infer<typeof settlementLagSchema>;
 export type SettlementReport = Readonly<{
     actions: readonly SettlementAction[];
     lags: readonly SettlementLag[];
     seatClose?: readonly PrivateStateSeatCloseLag[];
 }>;
+type SettlementProgress = Readonly<{
+    recordSettlement(contractId: ContractId, report: SettlementReport): void;
+}>;
 export type SettlementInput = Readonly<{
     repository: GitRepository;
     channel: GitDecodeChannel;
     state: ContractState | null;
     effects: readonly Effect[];
+    progress?: SettlementProgress;
 }>;
 export type SettlementBatchInput = Readonly<{
     repository: GitRepository;
@@ -36,3 +44,4 @@ export type SettlementBatchInput = Readonly<{
 }>;
 export declare function settle(input: SettlementInput): Promise<SettlementReport>;
 export declare function settleAll(input: SettlementBatchInput): Promise<readonly SettlementReport[]>;
+export {};

package/build/src/settlement/settle.js

@@ -1,10 +1,38 @@
+import { contractIdSchema } from "../git/identity.js";
+import { z } from "zod";
+import { taskIdSchema } from "../task/identity.js";
 import { observeContractsForAdmissionAt } from "../git/observe.js";
 import { appendPrivateStateSeatClose, withPrivateStatePublicationSeat, } from "../git/private-state-seat.js";
+import { GitPlumbingError } from "../git/process.js";
+import { SqliteTransactionLockError } from "../coordination/sqlite-transaction-lock.js";
+import { AuthorityCorruptionError } from "../core/facts/errors.js";
 import { settleTask } from "../task/operations.js";
 import { publishTaskHolderRelease, readTaskHolderProjectionFromDecision, taskHolderObservationSelection, } from "./holder.js";
 import { acquireTaskSettlementFence } from "./fence.js";
 import { World } from "../world.js";
-export { decodeSettlementLag } from "./result-codec.js";
+export const settlementActionSchema = z
+    .object({ kind: z.literal("task"), taskId: taskIdSchema, action: z.literal("done") })
+    .strict();
+export const settlementLagSchema = z
+    .object({
+    kind: z.literal("settlement-failed"),
+    surface: z.enum(["task-holder", "task"]),
+    contractId: contractIdSchema,
+    taskId: taskIdSchema.optional(),
+    path: z
+        .string()
+        .refine((value) => value.trim() !== "")
+        .optional(),
+    diagnostic: z.string().refine((value) => value.trim() !== ""),
+})
+    .strict();
+function operational(error) {
+    return (error instanceof Error &&
+        !(error instanceof AuthorityCorruptionError) &&
+        (error instanceof GitPlumbingError ||
+            error instanceof SqliteTransactionLockError ||
+            ("code" in error && typeof error.code === "string" && /^E[A-Z0-9]+$/u.test(error.code))));
+}
 function diagnostic(error) {
     return error instanceof Error ? error.message : String(error);
 }
@@ -13,8 +41,16 @@ function taskFailure(result) {
         ? `Task settlement requires retry: ${result.reason}`
         : `Task settlement refused: ${JSON.stringify(result.refusal)}`;
 }
+function recordLag(input, lag) {
+    input.lags.push(lag);
+    input.progress?.recordSettlement(input.candidate.id, { actions: [], lags: [lag] });
+}
+function recordAction(input, action) {
+    input.actions.push(action);
+    input.progress?.recordSettlement(input.candidate.id, { actions: [action], lags: [] });
+}
 async function observeApplicableHolder(input) {
-    const { repository, channel, candidate, lags } = input;
+    const { repository, channel, candidate } = input;
     let observation;
     try {
         observation = await observeContractsForAdmissionAt(repository, channel, [candidate.id], taskHolderObservationSelection());
@@ -25,7 +61,9 @@ async function observeApplicableHolder(input) {
         return holder?.disposition === "held" ? holder : null;
     }
     catch (error) {
-        lags.push({
+        if (!operational(error))
+            throw error;
+        recordLag(input, {
             kind: "settlement-failed",
             surface: "task-holder",
             contractId: candidate.id,
@@ -35,13 +73,15 @@ async function observeApplicableHolder(input) {
     }
 }
 async function completeHeldTask(input) {
-    const { repository, candidate, actions, lags, taskId } = input;
+    const { repository, candidate, taskId } = input;
     let world;
     try {
         world = await World.at(repository.primaryWorktree);
     }
     catch (error) {
-        lags.push({
+        if (!operational(error))
+            throw error;
+        recordLag(input, {
             kind: "settlement-failed",
             surface: "task",
             contractId: candidate.id,
@@ -55,7 +95,9 @@ async function completeHeldTask(input) {
         result = await settleTask(world, taskId);
     }
     catch (error) {
-        lags.push({
+        if (!operational(error))
+            throw error;
+        recordLag(input, {
             kind: "settlement-failed",
             surface: "task",
             contractId: candidate.id,
@@ -65,10 +107,10 @@ async function completeHeldTask(input) {
         return false;
     }
     if (result.kind === "changed")
-        actions.push({ kind: "task", taskId, action: "done" });
+        recordAction(input, { kind: "task", taskId, action: "done" });
     if (result.kind === "changed" && result.cleanup !== undefined) {
         for (const detail of result.cleanup.diagnostics) {
-            lags.push({
+            recordLag(input, {
                 kind: "settlement-failed",
                 surface: "task",
                 contractId: candidate.id,
@@ -79,7 +121,7 @@ async function completeHeldTask(input) {
     }
     if (result.kind === "changed" || result.kind === "unchanged")
         return true;
-    lags.push({
+    recordLag(input, {
         kind: "settlement-failed",
         surface: "task",
         contractId: candidate.id,
@@ -89,7 +131,7 @@ async function completeHeldTask(input) {
     return false;
 }
 async function releaseHeldTaskHolder(input) {
-    const { repository, channel, candidate, lags, seatClose, taskId } = input;
+    const { repository, channel, candidate, seatClose, taskId } = input;
     try {
         const outcome = await withPrivateStatePublicationSeat(repository, async (seat) => {
             const observation = await observeContractsForAdmissionAt(repository, channel, [candidate.id], taskHolderObservationSelection());
@@ -101,7 +143,7 @@ async function releaseHeldTaskHolder(input) {
                 return "inert";
             const publication = await publishTaskHolderRelease(repository, channel, observation, candidate.id, seat);
             if (publication.kind === "non-published") {
-                lags.push({
+                recordLag(input, {
                     kind: "settlement-failed",
                     surface: "task-holder",
                     contractId: candidate.id,
@@ -114,11 +156,14 @@ async function releaseHeldTaskHolder(input) {
         });
         if (outcome.closeLag !== undefined) {
             seatClose.push(...appendPrivateStateSeatClose(undefined, outcome.closeLag));
+            input.progress?.recordSettlement(candidate.id, { actions: [], lags: [], seatClose: [outcome.closeLag] });
         }
         return outcome.value;
     }
     catch (error) {
-        lags.push({
+        if (!operational(error))
+            throw error;
+        recordLag(input, {
             kind: "settlement-failed",
             surface: "task-holder",
             contractId: candidate.id,
@@ -129,8 +174,8 @@ async function releaseHeldTaskHolder(input) {
     }
 }
 async function settleTasks(input) {
-    const { repository, channel, candidate, actions, lags, seatClose } = input;
-    const hint = await observeApplicableHolder({ repository, channel, candidate, lags });
+    const { repository, channel, candidate, lags, seatClose } = input;
+    const hint = await observeApplicableHolder(input);
     if (hint === null)
         return false;
     const taskId = hint.taskId;
@@ -139,7 +184,9 @@ async function settleTasks(input) {
         fence = await acquireTaskSettlementFence(repository, taskId);
     }
     catch (error) {
-        lags.push({
+        if (!operational(error))
+            throw error;
+        recordLag(input, {
             kind: "settlement-failed",
             surface: "task",
             contractId: candidate.id,
@@ -148,13 +195,14 @@ async function settleTasks(input) {
         });
         return true;
     }
+    let failure;
     let taskSettled = false;
     let holderDisposition = null;
     try {
-        const holder = await observeApplicableHolder({ repository, channel, candidate, lags });
+        const holder = await observeApplicableHolder(input);
         if (holder === null || holder.taskId !== taskId)
             return false;
-        taskSettled = await completeHeldTask({ repository, candidate, actions, lags, taskId });
+        taskSettled = await completeHeldTask({ ...input, taskId });
         if (!taskSettled)
             return true;
         holderDisposition = await releaseHeldTaskHolder({
@@ -164,19 +212,28 @@ async function settleTasks(input) {
             taskId,
             lags,
             seatClose,
+            ...(input.progress === undefined ? {} : { progress: input.progress }),
         });
         return true;
     }
+    catch (error) {
+        failure = { error };
+        throw error;
+    }
     finally {
         try {
             await fence.close();
         }
         catch (error) {
-            if (!taskSettled)
+            if (!operational(error)) {
+                if (failure === undefined)
+                    throw error;
+            }
+            else if (!taskSettled && failure === undefined)
                 throw error;
             // Post-release fence teardown is custodial residue, not an owed holder publication.
             if (holderDisposition !== "released") {
-                lags.push({
+                recordLag(input, {
                     kind: "settlement-failed",
                     surface: "task-holder",
                     contractId: candidate.id,
@@ -208,10 +265,13 @@ async function settleObserved(input) {
                 actions,
                 lags,
                 seatClose,
+                ...(input.progress === undefined ? {} : { progress: input.progress }),
             });
         }
         catch (error) {
-            lags.push({
+            if (!operational(error))
+                throw error;
+            recordLag({ candidate, lags, ...(input.progress === undefined ? {} : { progress: input.progress }) }, {
                 kind: "settlement-failed",
                 surface: "task",
                 contractId: candidate.id,

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

@@ -1,4 +1,4 @@
-import type { TaskDocument, TaskPriority, TaskState } from "./document.js";
+import { type TaskDocument, type TaskPriority, type TaskState } from "./document.js";
 import { type TaskId } from "./identity.js";
 import { z } from "zod";
 import { type BoundedList } from "../bounded-list.js";
@@ -87,6 +87,8 @@ export type TaskTreeNode = Readonly<{
 export type TaskBoard = Readonly<{
     tasks: ReadonlyMap<TaskId, TaskDocument>;
 }>;
+/** The local ids occupied across one namespace of the current board. */
+export declare function occupiedLocalIds(board: TaskBoard, namespace: readonly string[]): Set<string>;
 type TaskRelation = "needs" | "parent" | "supersedes" | "relates";
 export type TaskDoctorIssue = Readonly<{
     kind: "missing-target";

package/build/src/task/board.js

@@ -1,25 +1,14 @@
-import { formatTaskId, parseTaskId, sameNamespace } from "./identity.js";
+import { taskNonblankTextSchema, taskStateSchema, taskPrioritySchema, } from "./document.js";
+import { taskIdSchema, parseTaskId, sameNamespace } from "./identity.js";
 import { z } from "zod";
 import { boundedListLimit, projectBoundedList } from "../bounded-list.js";
-const taskRowIdSchema = z.string().transform((value, context) => {
-    try {
-        const id = formatTaskId(parseTaskId(value));
-        if (id !== value)
-            throw new Error("not canonical");
-        return id;
-    }
-    catch {
-        context.addIssue({ code: "custom", message: "expected canonical TaskId" });
-        return z.NEVER;
-    }
-});
 const taskRowTimestampSchema = z.string().refine((value) => Number.isFinite(Date.parse(value)), "expected timestamp");
 export const taskRowSchema = z
     .object({
-    id: taskRowIdSchema,
-    title: z.string().refine((value) => value.trim() !== ""),
-    state: z.enum(["open", "in_progress", "on_hold", "done", "drop"]),
-    priority: z.union([z.literal(0), z.literal(1), z.literal(2), z.literal(3)]),
+    id: taskIdSchema,
+    title: taskNonblankTextSchema,
+    state: taskStateSchema,
+    priority: taskPrioritySchema,
     disposition: z.enum(["ready", "blocked", "in_progress", "on_hold", "done", "drop"]),
     updatedAt: taskRowTimestampSchema,
     bodyPresent: z.boolean(),
@@ -30,6 +19,13 @@ export const taskRowSchema = z
 })
     .strict();
 export const taskRowsSchema = z.array(taskRowSchema).readonly();
+/** The local ids occupied across one namespace of the current board. */
+export function occupiedLocalIds(board, namespace) {
+    return new Set([...board.tasks.values()].flatMap((task) => {
+        const coordinate = parseTaskId(task.id);
+        return sameNamespace(coordinate.namespace, namespace) ? [coordinate.localId] : [];
+    }));
+}
 const terminal = (state) => state === "done" || state === "drop";
 const none = Object.freeze([]);
 const sorted = (values) => [...values].sort((a, b) => Buffer.compare(Buffer.from(a.id), Buffer.from(b.id)));

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

@@ -9,7 +9,3 @@ export declare function observeRecentTaskStatus(world: WorldRoot, input?: Readon
     namespace?: readonly string[];
     limit?: number;
 }>): Promise<BoundedList<RecentTaskStatusRow>>;
-export declare function observeTaskCatalog(world: WorldRoot, input?: Readonly<{
-    namespace?: readonly string[];
-    limit?: number;
-}>): Promise<BoundedList<TaskRow>>;

package/build/src/task/catalog.js

@@ -60,18 +60,3 @@ async function recentTaskStatus(world, input) {
 export async function observeRecentTaskStatus(world, input = {}) {
     return recentTaskStatus(world, input);
 }
-export async function observeTaskCatalog(world, input = {}) {
-    const { namespace } = input;
-    if (namespace !== undefined && !namespace.every(isTaskSegment)) {
-        throw new TypeError("namespace must contain canonical segments");
-    }
-    const documents = await readRecentTaskDocuments(world, {
-        ...(namespace === undefined ? {} : { namespace }),
-        ...(input.limit === undefined ? {} : { limit: input.limit }),
-    });
-    const known = new Map(documents.rows.map((document) => [document.id, document]));
-    return {
-        rows: (await Promise.all(documents.rows.map((document) => catalogRow(world, document, known)))).map(({ blockers: _blockers, ...row }) => row),
-        hasMore: documents.hasMore,
-    };
-}

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

@@ -1,4 +1,5 @@
-import type { TaskBoard } from "./board.js";
+import { type TaskBoard } from "./board.js";
+import type { TaskCompositionResult } from "./mutation-result.js";
 import { type TaskDocument } from "./document.js";
 import { type TaskId } from "./identity.js";
 import { type TaskCompositionDiagnostic } from "./operations.js";
@@ -6,16 +7,17 @@ export declare function taskCompositionNamespaceHeader(markdown: string): Readon
     specified: boolean;
     namespace?: readonly string[];
 }>;
-export type TaskCompositionAlias = Readonly<{
-    alias: string;
-    taskId: TaskId;
+type PlannedComposition = Extract<TaskCompositionResult, {
+    kind: "planned";
 }>;
-export type TaskCompositionBodyPreview = Readonly<{
-    taskId: TaskId;
-    bytes: number;
-    firstLine: string;
-    lastLine: string;
+export type AcceptedComposition = Extract<TaskCompositionResult, {
+    kind: "accepted";
 }>;
+export type TaskCompositionAlias = Readonly<AcceptedComposition["aliases"][number]>;
+export type TaskCompositionPlanAlias = Readonly<PlannedComposition["aliases"][number]>;
+export type TaskCompositionPlanOrder = Readonly<PlannedComposition["admissionOrder"][number]>;
+export type TaskCompositionBodyPreview = Readonly<PlannedComposition["bodies"][number]>;
+export type TaskCompositionAdmission = Readonly<PlannedComposition["admissions"][number]>;
 export type PlannedTask = Readonly<{
     index: number;
     line: number;
@@ -29,6 +31,13 @@ export type TaskCompositionPlan = Readonly<{
     aliases: readonly TaskCompositionAlias[];
     admissionOrder: readonly TaskId[];
     bodies: readonly TaskCompositionBodyPreview[];
+    admissions: readonly Readonly<{
+        position: number;
+        kind: "new" | "existing";
+        taskId: TaskId;
+        alias?: string | undefined;
+        title: string;
+    }>[];
     tasks: readonly PlannedTask[];
 }>;
 export type TaskCompositionPlanning = Readonly<{
@@ -45,3 +54,4 @@ export declare function planTaskComposition(input: Readonly<{
     at: string;
     actor?: string;
 }>): TaskCompositionPlanning;
+export {};

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

@@ -1,5 +1,6 @@
+import { occupiedLocalIds } from "./board.js";
 import { serializeTaskDocument } from "./document.js";
-import { allocateLocalId, deriveLocalStem, formatTaskId, parseTaskId, sameNamespace } from "./identity.js";
+import { allocateLocalId, deriveLocalStem, formatTaskId, parseTaskId } from "./identity.js";
 import { parseTaskComposition } from "./compose-parser.js";
 import { advanceTaskTimestamp } from "./operations.js";
 export function taskCompositionNamespaceHeader(markdown) {
@@ -12,12 +13,6 @@ export function taskCompositionNamespaceHeader(markdown) {
 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,
@@ -39,7 +34,7 @@ function aliasFor(node) {
     return node.assignments.find((item) => item.field === "as");
 }
 function allocateNodes(input, diagnostics) {
-    const ids = occupied(input.board, input.namespace);
+    const ids = occupiedLocalIds(input.board, input.namespace);
     const allocations = new Map();
     for (const node of input.parsed.nodes) {
         if (node.kind !== "new")
@@ -275,17 +270,38 @@ function stableAdmissionOrder(tasks, diagnostics) {
     }
     return ordered;
 }
-function bodyPreview(node, id) {
+function bodyPreview(node, title) {
     if (node.body?.kind !== "replace")
         return null;
     const lines = node.body.value.split(/\r\n|\n|\r/u);
     return {
-        taskId: id,
+        position: node.index + 1,
+        title,
         bytes: Buffer.byteLength(node.body.value),
         firstLine: lines[0] ?? "",
         lastLine: lines.at(-1) ?? "",
     };
 }
+function planPresentation(ordered, tasks, parsed, aliases) {
+    const aliasBindings = [...aliases].map(([alias, taskId]) => ({ alias, taskId }));
+    const admissions = ordered.map((task) => task.kind === "new"
+        ? {
+            position: task.index + 1,
+            kind: "new",
+            ...(task.alias === undefined ? {} : { alias: task.alias }),
+            title: task.after.title,
+            taskId: task.after.id,
+        }
+        : { position: task.index + 1, kind: "existing", taskId: task.after.id, title: task.after.title });
+    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.title);
+        return preview === null ? [] : [preview];
+    });
+    return { aliases: aliasBindings, admissions, bodies };
+}
 export function planTaskComposition(input) {
     const parsed = parseTaskComposition(input.markdown);
     const diagnostics = [...parsed.diagnostics];
@@ -333,21 +349,15 @@ export function planTaskComposition(input) {
     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];
-    });
+    const presentation = planPresentation(ordered, tasks, parsed, aliases);
     return {
         kind: "planned",
         plan: {
             namespace,
-            aliases: aliasBindings,
+            aliases: presentation.aliases,
             admissionOrder: ordered.map((task) => task.after.id),
-            bodies,
+            admissions: presentation.admissions,
+            bodies: presentation.bodies,
             tasks: ordered,
         },
     };