@astrosheep/keiyaku 4.5.11 → 4.5.13

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

@@ -1,20 +1,18 @@
 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";
+import { type TaskId } from "../task/identity.js";
+export { decodeSettlementLag } from "./result-codec.js";
 export type SettlementAction = Readonly<{
     kind: "task";
     taskId: TaskId;
     action: "done";
-}> | Readonly<{
-    kind: "namespace-context";
-    path: string;
-    action: "installed" | "kept";
 }>;
 export type SettlementLag = Readonly<{
     kind: "settlement-failed";
-    surface: "task-holder" | "task" | "namespace-context";
+    surface: "task-holder" | "task";
     contractId: ContractId;
     taskId?: TaskId;
     path?: string;
@@ -23,13 +21,8 @@ export type SettlementLag = Readonly<{
 export type SettlementReport = Readonly<{
     actions: readonly SettlementAction[];
     lags: readonly SettlementLag[];
+    seatClose?: readonly PrivateStateSeatCloseLag[];
 }>;
-export declare function deferredTaskHolderSettlement(input: Readonly<{
-    contractId: ContractId;
-    taskId: TaskId;
-    diagnostic: string;
-}>): SettlementReport;
-export declare function contractNamespace(id: ContractId): readonly [string];
 export type SettlementInput = Readonly<{
     repository: GitRepository;
     channel: GitDecodeChannel;

package/build/src/settlement/settle.js

@@ -1,17 +1,10 @@
-import { contractSegment } from "../core/facts/types.js";
 import { observeContractsForAdmissionAt } from "../git/observe.js";
-import { withPrivateStatePublicationSeat } from "../git/private-state-seat.js";
-import { repairNamespaceContext } from "../task/context.js";
+import { appendPrivateStateSeatClose, withPrivateStatePublicationSeat, } from "../git/private-state-seat.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 function deferredTaskHolderSettlement(input) {
-    return { actions: [], lags: [{ kind: "settlement-failed", surface: "task-holder", ...input }] };
-}
-export function contractNamespace(id) {
-    return [contractSegment(id)];
-}
+export { decodeSettlementLag } from "./result-codec.js";
 function diagnostic(error) {
     return error instanceof Error ? error.message : String(error);
 }
@@ -73,6 +66,17 @@ async function completeHeldTask(input) {
     }
     if (result.kind === "changed")
         actions.push({ kind: "task", taskId, action: "done" });
+    if (result.kind === "changed" && result.cleanup !== undefined) {
+        for (const detail of result.cleanup.diagnostics) {
+            lags.push({
+                kind: "settlement-failed",
+                surface: "task",
+                contractId: candidate.id,
+                taskId,
+                diagnostic: detail,
+            });
+        }
+    }
     if (result.kind === "changed" || result.kind === "unchanged")
         return true;
     lags.push({
@@ -85,16 +89,16 @@ async function completeHeldTask(input) {
     return false;
 }
 async function releaseHeldTaskHolder(input) {
-    const { repository, channel, candidate, lags, taskId } = input;
+    const { repository, channel, candidate, lags, seatClose, taskId } = input;
     try {
-        await withPrivateStatePublicationSeat(repository, async (seat) => {
+        const outcome = await withPrivateStatePublicationSeat(repository, async (seat) => {
             const observation = await observeContractsForAdmissionAt(repository, channel, [candidate.id], taskHolderObservationSelection());
             const state = observation.journals.get(candidate.id)?.state ?? null;
             if (state === null || state.terminal?.kind !== "claimed")
-                return;
+                return "inert";
             const holder = (await readTaskHolderProjectionFromDecision(channel, observation)).get(candidate.id) ?? null;
             if (holder === null || holder.disposition !== "held" || holder.taskId !== taskId)
-                return;
+                return "inert";
             const publication = await publishTaskHolderRelease(repository, channel, observation, candidate.id, seat);
             if (publication.kind === "non-published") {
                 lags.push({
@@ -104,8 +108,14 @@ async function releaseHeldTaskHolder(input) {
                     taskId,
                     diagnostic: `Task holder release requires retry: ${publication.diagnostic}`,
                 });
+                return "held";
             }
+            return publication.kind === "released" ? "released" : "inert";
         });
+        if (outcome.closeLag !== undefined) {
+            seatClose.push(...appendPrivateStateSeatClose(undefined, outcome.closeLag));
+        }
+        return outcome.value;
     }
     catch (error) {
         lags.push({
@@ -115,10 +125,11 @@ async function releaseHeldTaskHolder(input) {
             taskId,
             diagnostic: diagnostic(error),
         });
+        return "held";
     }
 }
 async function settleTasks(input) {
-    const { repository, channel, candidate, actions, lags } = input;
+    const { repository, channel, candidate, actions, lags, seatClose } = input;
     const hint = await observeApplicableHolder({ repository, channel, candidate, lags });
     if (hint === null)
         return false;
@@ -138,14 +149,22 @@ async function settleTasks(input) {
         return true;
     }
     let taskSettled = false;
+    let holderDisposition = null;
     try {
         const holder = await observeApplicableHolder({ repository, channel, candidate, lags });
         if (holder === null || holder.taskId !== taskId)
             return false;
-        if (!(await completeHeldTask({ repository, candidate, actions, lags, taskId })))
+        taskSettled = await completeHeldTask({ repository, candidate, actions, lags, taskId });
+        if (!taskSettled)
             return true;
-        taskSettled = true;
-        await releaseHeldTaskHolder({ repository, channel, candidate, taskId, lags });
+        holderDisposition = await releaseHeldTaskHolder({
+            repository,
+            channel,
+            candidate,
+            taskId,
+            lags,
+            seatClose,
+        });
         return true;
     }
     finally {
@@ -155,66 +174,52 @@ async function settleTasks(input) {
         catch (error) {
             if (!taskSettled)
                 throw error;
-            lags.push({
-                kind: "settlement-failed",
-                surface: "task-holder",
-                contractId: candidate.id,
-                taskId,
-                diagnostic: diagnostic(error),
-            });
+            // Post-release fence teardown is custodial residue, not an owed holder publication.
+            if (holderDisposition !== "released") {
+                lags.push({
+                    kind: "settlement-failed",
+                    surface: "task-holder",
+                    contractId: candidate.id,
+                    taskId,
+                    diagnostic: diagnostic(error),
+                });
+            }
         }
     }
 }
-async function settleNamespace(state, effects, actions, lags) {
-    if (state.coordinates.workspace !== "worktree")
-        return;
-    const worktrees = effects.filter((effect) => effect.kind === "worktree" && effect.action !== "removed");
-    for (const effect of worktrees) {
-        try {
-            actions.push({
-                kind: "namespace-context",
-                path: effect.path,
-                action: await repairNamespaceContext(effect.path, contractNamespace(state.id)),
-            });
-        }
-        catch (error) {
-            lags.push({
-                kind: "settlement-failed",
-                surface: "namespace-context",
-                contractId: state.id,
-                path: effect.path,
-                diagnostic: diagnostic(error),
-            });
-        }
-    }
+function settlementReport(actions, lags, seatClose) {
+    return {
+        actions,
+        lags,
+        ...(seatClose.length === 0 ? {} : { seatClose }),
+    };
 }
 async function settleObserved(input) {
     if (input.state === null)
         return { actions: [], lags: [] };
-    const actions = [], lags = [];
-    let holderApplies = false;
-    if (input.state.terminal?.kind === "claimed") {
+    const actions = [], lags = [], seatClose = [];
+    const candidate = input.state;
+    if (candidate.terminal?.kind === "claimed") {
         try {
-            holderApplies = await settleTasks({
+            await settleTasks({
                 repository: input.repository,
                 channel: input.channel,
-                candidate: input.state,
+                candidate,
                 actions,
                 lags,
+                seatClose,
             });
         }
         catch (error) {
             lags.push({
                 kind: "settlement-failed",
                 surface: "task",
-                contractId: input.state.id,
+                contractId: candidate.id,
                 diagnostic: diagnostic(error),
             });
         }
     }
-    if (holderApplies)
-        await settleNamespace(input.state, input.effects, actions, lags);
-    return { actions, lags };
+    return settlementReport(actions, lags, seatClose);
 }
 function onPrimaryWorktree(repository) {
     return { ...repository, effectiveCwd: repository.primaryWorktree };

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

@@ -1,6 +1,7 @@
 import type { TaskDocument, TaskPriority, TaskState } from "./document.js";
 import { type TaskId } from "./identity.js";
 import { z } from "zod";
+import { type BoundedList } from "../bounded-list.js";
 export type TaskRef = Readonly<{
     id: TaskId;
     title: string | null;
@@ -111,6 +112,7 @@ export type TaskRelationProjection = Readonly<{
 export declare function createTaskRelations(board: TaskBoard): TaskRelationProjection;
 export declare function taskDisposition(board: TaskBoard, task: TaskDocument): TaskDisposition;
 export declare function taskBlocked(board: TaskBoard, task: TaskDocument): boolean;
+export declare function projectOwnedDetailFacts(board: TaskBoard, id: TaskId): TaskDetailFacts | null;
 export declare function projectDetailFacts(board: TaskBoard, id: TaskId, relations: TaskRelationProjection): TaskDetailFacts | null;
 export declare function projectTaskRow(board: TaskBoard, relations: TaskRelationProjection, task: TaskDocument): TaskRow;
 export declare function projectRows(board: TaskBoard, relations: TaskRelationProjection, scope: readonly string[] | null, selection: "active" | "closed" | "all"): readonly TaskRow[];
@@ -147,6 +149,7 @@ export declare function projectStatusRows(board: TaskBoard, relations: TaskRelat
 })[];
 export type TaskBoardObservation = Readonly<{
     statusRows: ReturnType<typeof projectStatusRows>;
+    selectRecentStatus(limit?: number): BoundedList<ReturnType<typeof projectStatusRows>[number]>;
     selectNamespace(namespace: readonly string[]): readonly TaskRow[];
     selectCreatedBy(createdBy: string): readonly TaskRow[];
 }>;

package/build/src/task/board.js

@@ -1,5 +1,6 @@
 import { formatTaskId, 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));
@@ -93,7 +94,7 @@ export function taskDisposition(board, task) {
 export function taskBlocked(board, task) {
     return (task.state === "open" || task.state === "in_progress") && hasUnresolvedNeeds(board, task);
 }
-export function projectDetailFacts(board, id, relations) {
+export function projectOwnedDetailFacts(board, id) {
     const task = board.tasks.get(id);
     if (task === undefined)
         return null;
@@ -102,10 +103,22 @@ export function projectDetailFacts(board, id, relations) {
         task,
         needs,
         blockers: needs.filter((need) => !need.released).map(({ released: _released, ...ref }) => ref),
-        blocks: relations.blocks(id),
+        blocks: none,
         parent: task.parent === null ? null : taskRef(board, task.parent),
-        children: relations.children(id),
+        children: none,
         supersedes: task.supersedes.map((target) => taskRef(board, target)),
+        supersededBy: none,
+        related: task.relates.length === 0 ? none : sorted(task.relates.map((target) => taskRef(board, target))),
+    };
+}
+export function projectDetailFacts(board, id, relations) {
+    const owned = projectOwnedDetailFacts(board, id);
+    if (owned === null)
+        return null;
+    return {
+        ...owned,
+        blocks: relations.blocks(id),
+        children: relations.children(id),
         supersededBy: relations.supersededBy(id),
         related: relations.related(id),
     };
@@ -152,8 +165,13 @@ export function projectStatusRows(board, relations, scope) {
 export function projectTaskBoardObservation(board) {
     const relations = createTaskRelations(board);
     const rows = projectRows(board, relations, null, "all");
+    const statusRows = projectStatusRows(board, relations, null);
     return {
-        statusRows: projectStatusRows(board, relations, null),
+        statusRows,
+        selectRecentStatus: (limit) => projectBoundedList(statusRows
+            .filter((row) => row.state !== "done" && row.state !== "drop")
+            .sort((left, right) => right.updatedAt.localeCompare(left.updatedAt) ||
+            Buffer.compare(Buffer.from(left.id), Buffer.from(right.id))), boundedListLimit(limit)),
         selectNamespace: (namespace) => projectRows(board, relations, namespace, "all"),
         selectCreatedBy: (createdBy) => rows.filter((row) => board.tasks.get(row.id)?.createdBy === createdBy),
     };

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

@@ -1,4 +1,15 @@
-import { type TaskRow } from "./board.js";
+import type { BoundedList } from "../bounded-list.js";
+import type { TaskRef, TaskRow } from "./board.js";
 import type { WorldRoot } from "../world.js";
 export declare function parseTaskNamespaceSelector(value: string): readonly string[];
-export declare function observeTaskCatalogRows(world: WorldRoot, namespace?: readonly string[]): Promise<readonly TaskRow[]>;
+export type RecentTaskStatusRow = TaskRow & Readonly<{
+    blockers?: readonly TaskRef[];
+}>;
+export declare function observeRecentTaskStatus(world: WorldRoot, input?: Readonly<{
+    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

@@ -1,6 +1,5 @@
-import { createTaskRelations, projectRows } from "./board.js";
 import { isTaskSegment, parseTaskId } from "./identity.js";
-import { readBoard } from "./store.js";
+import { readRecentTaskDocuments, readTaskDocument } from "./store.js";
 export function parseTaskNamespaceSelector(value) {
     if (value === "task/")
         return [];
@@ -14,10 +13,65 @@ export function parseTaskNamespaceSelector(value) {
     }
     return parseTaskId(`task/${body}/placeholder`).namespace;
 }
-export async function observeTaskCatalogRows(world, namespace) {
+function terminal(task) {
+    return task?.state === "done" || task?.state === "drop";
+}
+async function catalogRow(world, task, documents) {
+    const needs = await Promise.all(task.needs.map(async (id) => documents.get(id) ?? (await readTaskDocument(world, id))));
+    const blockers = [];
+    if (task.state === "open" || task.state === "in_progress") {
+        for (const [index, need] of needs.entries()) {
+            if (terminal(need))
+                continue;
+            blockers.push({ id: task.needs[index], title: need?.title ?? null, state: need?.state ?? "missing" });
+        }
+    }
+    return {
+        id: task.id,
+        title: task.title,
+        state: task.state,
+        priority: task.priority,
+        disposition: task.state === "open" && needs.some((need) => !terminal(need))
+            ? "blocked"
+            : task.state === "open"
+                ? "ready"
+                : task.state,
+        updatedAt: task.updatedAt,
+        bodyPresent: task.body.length > 0,
+        ...(blockers.length === 0 ? {} : { blockers }),
+    };
+}
+async function recentTaskStatus(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 }),
+        selection: "active",
+        ...(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))),
+        hasMore: documents.hasMore,
+    };
+}
+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 board = (await readBoard(world)).board;
-    return projectRows(board, createTaskRelations(board), namespace ?? null, "all");
+    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.d.ts

@@ -1,7 +1,7 @@
 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";
+import { type TaskId } from "./identity.js";
+import type { TaskCleanupFailure, TaskRefusal, TaskRetry } from "./operations.js";
 export type { TaskCompositionAlias, TaskCompositionBodyPreview } from "./compose-language.js";
 export { taskCompositionNamespaceHeader } from "./compose-language.js";
 export type TaskDocumentChange = Readonly<{
@@ -21,6 +21,7 @@ export type TaskCompositionResult = Readonly<{
 }> | Readonly<{
     kind: "accepted";
     documentChanges: readonly TaskDocumentChange[];
+    cleanup?: TaskCleanupFailure;
 } & TaskCompositionFacts> | Readonly<{
     kind: "refused";
     refusal: Extract<TaskRefusal, {
@@ -29,6 +30,7 @@ export type TaskCompositionResult = Readonly<{
 }> | (Readonly<{
     kind: "incomplete";
     documentChanges: readonly TaskDocumentChange[];
+    cleanup?: TaskCleanupFailure;
     stopped: TaskRefusal | Readonly<{
         kind: "retry";
         reason: TaskRetry;

package/build/src/task/compose.js

@@ -1,7 +1,8 @@
 import { documentDiff } from "../markdown/diff.js";
 import { planTaskComposition, } from "./compose-language.js";
 import { serializeTaskDocument } from "./document.js";
-import { authorityPath, readBoard, replaceAuthority, withTaskLocks } from "./store.js";
+import { parseTaskId, taskAuthorityPath } from "./identity.js";
+import { readBoard, replaceAuthority, withTaskLocks } from "./store.js";
 export { taskCompositionNamespaceHeader } from "./compose-language.js";
 function refusal(diagnostics) {
     return { kind: "refused", refusal: { kind: "invalid-composition", diagnostics } };
@@ -57,6 +58,19 @@ function recoveryDraft(namespace, remaining) {
 function plannedResult(plan) {
     return { kind: "planned", ...facts(plan), bodies: plan.bodies };
 }
+function physicalPlanDiagnostics(plan) {
+    try {
+        taskAuthorityPath("", { namespace: plan.namespace, localId: "placeholder" });
+        for (const task of plan.tasks)
+            taskAuthorityPath("", parseTaskId(task.after.id));
+        return [];
+    }
+    catch (error) {
+        return [
+            { line: 1, reason: error instanceof Error ? error.message : String(error), token: plan.namespace.join("/") },
+        ];
+    }
+}
 function planAgainst(markdown, board, namespace, at, actor) {
     return planTaskComposition({ markdown, board, namespace, at, ...(actor === undefined ? {} : { actor }) });
 }
@@ -70,7 +84,8 @@ async function admitPlan(world, snapshot, plan, signal) {
         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),
+            world,
+            id: item.after.id,
             expected: beforeBytes,
             next: afterBytes,
         });
@@ -115,32 +130,43 @@ function composeInput(input) {
 }
 export async function composeTasks(input) {
     const { world, markdown, signal, actor, defaultNamespace = [], planOnly = false } = input;
-    const at = currentTimestamp();
-    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 request = composeInput({
-        world,
-        markdown,
-        namespace: defaultNamespace,
-        at,
-        ...(actor === undefined ? {} : { actor }),
-        ...(signal === undefined ? {} : { 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(request))
-        : await composeUnderLocks(request);
-    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),
-    };
+    try {
+        const at = currentTimestamp();
+        const initial = await readBoard(world);
+        const initialPlan = planAgainst(markdown, initial.board, defaultNamespace, at, actor);
+        if (initialPlan.kind === "refused")
+            return refusal(initialPlan.diagnostics);
+        const physicalDiagnostics = physicalPlanDiagnostics(initialPlan.plan);
+        if (physicalDiagnostics.length > 0)
+            return refusal(physicalDiagnostics);
+        if (planOnly)
+            return plannedResult(initialPlan.plan);
+        const request = composeInput({
+            world,
+            markdown,
+            namespace: defaultNamespace,
+            at,
+            ...(actor === undefined ? {} : { actor }),
+            ...(signal === undefined ? {} : { 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(request))
+            : await composeUnderLocks(request);
+        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),
+        };
+    }
+    catch (error) {
+        if (error instanceof TypeError &&
+            /task identity (?:cannot fit the physical filename budget|contains a Windows-reserved physical segment)/u.test(error.message))
+            return refusal([{ line: 1, reason: error.message, token: defaultNamespace.join("/") }]);
+        throw error;
+    }
 }

package/build/src/task/created-observation.d.ts

@@ -0,0 +1,39 @@
+import type { WorldRoot } from "../world.js";
+import { z } from "zod";
+export declare const createdTaskObservationSchema: z.ZodUnion<readonly [z.ZodObject<{
+    kind: z.ZodLiteral<"present">;
+    rows: z.ZodReadonly<z.ZodArray<z.ZodObject<{
+        id: z.ZodPipe<z.ZodString, z.ZodTransform<`task/${string}`, string>>;
+        title: z.ZodString;
+        state: z.ZodEnum<{
+            open: "open";
+            in_progress: "in_progress";
+            on_hold: "on_hold";
+            done: "done";
+            drop: "drop";
+        }>;
+        priority: z.ZodUnion<readonly [z.ZodLiteral<0>, z.ZodLiteral<1>, z.ZodLiteral<2>, z.ZodLiteral<3>]>;
+        disposition: z.ZodEnum<{
+            in_progress: "in_progress";
+            on_hold: "on_hold";
+            done: "done";
+            drop: "drop";
+            ready: "ready";
+            blocked: "blocked";
+        }>;
+        updatedAt: z.ZodString;
+        bodyPresent: z.ZodBoolean;
+        children: z.ZodOptional<z.ZodObject<{
+            live: z.ZodNumber;
+            total: z.ZodNumber;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>>;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"failed">;
+    diagnostic: z.ZodString;
+}, z.core.$strict>]>;
+export type CreatedTaskObservation = z.infer<typeof createdTaskObservationSchema>;
+export declare const EMPTY_CREATED_TASK_OBSERVATION: CreatedTaskObservation;
+export declare function parseCreatedTaskObservation(value: unknown): CreatedTaskObservation;
+/** Project Task board rows created by each identity, preserving input order. */
+export declare function observeCreatedTaskObservations(world: WorldRoot, createdByIds: readonly string[]): Promise<readonly CreatedTaskObservation[]>;

package/build/src/task/created-observation.js

@@ -0,0 +1,26 @@
+import { z } from "zod";
+import { taskRowsSchema } from "./board.js";
+import { observeTaskBoard } from "./operations.js";
+export const createdTaskObservationSchema = z.union([
+    z.object({ kind: z.literal("present"), rows: taskRowsSchema }).strict(),
+    z.object({ kind: z.literal("failed"), diagnostic: z.string() }).strict(),
+]);
+export const EMPTY_CREATED_TASK_OBSERVATION = { kind: "present", rows: [] };
+export function parseCreatedTaskObservation(value) {
+    return createdTaskObservationSchema.parse(value);
+}
+function observationDiagnostic(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+/** Project Task board rows created by each identity, preserving input order. */
+export async function observeCreatedTaskObservations(world, createdByIds) {
+    let board;
+    try {
+        board = await observeTaskBoard(world);
+    }
+    catch (error) {
+        const failed = { kind: "failed", diagnostic: observationDiagnostic(error) };
+        return createdByIds.map(() => failed);
+    }
+    return createdByIds.map((createdBy) => parseCreatedTaskObservation({ kind: "present", rows: board.selectCreatedBy(createdBy) }));
+}

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

@@ -1,12 +1,18 @@
+import { type ContractId } from "../core/facts/types.js";
 export type TaskId = `task/${string}`;
 export type TaskCoordinate = Readonly<{
     namespace: readonly string[];
     localId: string;
 }>;
+export declare const TASK_LOCK_ID_BYTES: number;
+export declare const TASK_LOCAL_ID_BYTES: number;
 export declare function isTaskSegment(value: string): boolean;
 export declare function parseTaskId(value: string): TaskCoordinate;
 export declare function formatTaskId(coordinate: TaskCoordinate): TaskId;
+export declare function canonicalTaskId(value: string): TaskId;
+export declare function contractNamespace(id: ContractId): readonly string[];
 export declare function taskAuthorityPath(tasksDirectory: string, coordinate: TaskCoordinate): string;
 export declare function deriveLocalStem(title: string): string;
 export declare function allocateLocalId(stem: string, occupied: ReadonlySet<string>): string;
+export declare function physicalTaskSegment(segment: string, maxBytes?: number): string;
 export declare function sameNamespace(left: readonly string[], right: readonly string[]): boolean;