@astrosheep/keiyaku 4.5.29 → 4.6.2

package/build/src/task/mutation-result.d.ts

@@ -1,18 +1,123 @@
-import type { TaskCompositionResult } from "./compose.js";
-import type { TaskBatchResult, TaskMutationResult, TaskUpdateResult } from "./operations.js";
 import { z } from "zod";
-export type TaskMutationExecutionResult = TaskMutationResult | TaskUpdateResult | TaskBatchResult | TaskCompositionResult;
+export { taskIdSchema as taskMutationIdSchema } from "./identity.js";
 type WithoutUndefined<Value> = {
     [Key in keyof Value as undefined extends Value[Key] ? never : Key]: Value[Key];
 } & {
     [Key in keyof Value as undefined extends Value[Key] ? Key : never]?: Exclude<Value[Key], undefined>;
 };
-export declare const taskMutationIdSchema: z.ZodPipe<z.ZodString, z.ZodTransform<`task/${string}`, string>>;
+declare const taskRetrySchema: z.ZodObject<{
+    kind: z.ZodLiteral<"retry">;
+    reason: z.ZodEnum<{
+        "concurrent-modification": "concurrent-modification";
+        busy: "busy";
+    }>;
+}, z.core.$strict>;
+declare const taskCleanupFailureSchema: z.ZodObject<{
+    kind: z.ZodLiteral<"lock-release-failed">;
+    diagnostics: z.ZodReadonly<z.ZodArray<z.ZodString>>;
+}, z.core.$strict>;
+declare const taskViewSchema: z.ZodPipe<z.ZodObject<{
+    id: z.ZodPipe<z.ZodString, z.ZodTransform<`task/${string}`, string>>;
+    namespace: z.ZodReadonly<z.ZodArray<z.ZodString>>;
+    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>]>;
+    needs: z.ZodReadonly<z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<`task/${string}`, string>>>>;
+    parent: z.ZodNullable<z.ZodPipe<z.ZodString, z.ZodTransform<`task/${string}`, string>>>;
+    supersedes: z.ZodReadonly<z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<`task/${string}`, string>>>>;
+    relates: z.ZodReadonly<z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<`task/${string}`, string>>>>;
+    note: z.ZodString;
+    createdBy: z.ZodOptional<z.ZodString>;
+    createdAt: z.ZodString;
+    updatedAt: z.ZodString;
+    body: z.ZodString;
+}, z.core.$strict>, z.ZodTransform<WithoutUndefined<{
+    createdBy: string | undefined;
+    id: `task/${string}`;
+    namespace: readonly string[];
+    title: string;
+    state: "open" | "in_progress" | "on_hold" | "done" | "drop";
+    priority: 0 | 1 | 2 | 3;
+    needs: readonly `task/${string}`[];
+    parent: `task/${string}` | null;
+    supersedes: readonly `task/${string}`[];
+    relates: readonly `task/${string}`[];
+    note: string;
+    createdAt: string;
+    updatedAt: string;
+    body: string;
+}>, {
+    id: `task/${string}`;
+    namespace: readonly string[];
+    title: string;
+    state: "open" | "in_progress" | "on_hold" | "done" | "drop";
+    priority: 0 | 1 | 2 | 3;
+    needs: readonly `task/${string}`[];
+    parent: `task/${string}` | null;
+    supersedes: readonly `task/${string}`[];
+    relates: readonly `task/${string}`[];
+    note: string;
+    createdAt: string;
+    updatedAt: string;
+    body: string;
+    createdBy?: string | undefined;
+}>>;
+declare const compositionDiagnosticSchema: z.ZodObject<{
+    line: z.ZodNumber;
+    reason: z.ZodString;
+    token: z.ZodString;
+}, z.core.$strict>;
+export declare const taskRefusalSchema: z.ZodUnion<readonly [z.ZodObject<{
+    kind: z.ZodLiteral<"task-missing">;
+    taskId: z.ZodPipe<z.ZodString, z.ZodTransform<`task/${string}`, string>>;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"invalid-lifecycle-transition">;
+    taskId: z.ZodPipe<z.ZodString, z.ZodTransform<`task/${string}`, string>>;
+    state: z.ZodEnum<{
+        open: "open";
+        in_progress: "in_progress";
+        on_hold: "on_hold";
+        done: "done";
+        drop: "drop";
+    }>;
+    verb: z.ZodEnum<{
+        done: "done";
+        drop: "drop";
+        start: "start";
+        stop: "stop";
+        hold: "hold";
+        resume: "resume";
+    }>;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"invalid-graph">;
+    diagnostic: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"invalid-namespace-context">;
+    path: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"relation-owned-by-other">;
+    taskId: z.ZodPipe<z.ZodString, z.ZodTransform<`task/${string}`, string>>;
+    related: z.ZodPipe<z.ZodString, z.ZodTransform<`task/${string}`, string>>;
+    declaringTask: z.ZodPipe<z.ZodString, z.ZodTransform<`task/${string}`, string>>;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"invalid-composition">;
+    diagnostics: z.ZodReadonly<z.ZodArray<z.ZodObject<{
+        line: z.ZodNumber;
+        reason: z.ZodString;
+        token: z.ZodString;
+    }, z.core.$strict>>>;
+}, z.core.$strict>]>;
 export declare const taskMutationResultSchema: z.ZodUnion<readonly [z.ZodPipe<z.ZodObject<{
     kind: z.ZodLiteral<"accepted">;
     value: z.ZodPipe<z.ZodObject<{
         id: z.ZodPipe<z.ZodString, z.ZodTransform<`task/${string}`, string>>;
-        namespace: z.ZodArray<z.ZodString>;
+        namespace: z.ZodReadonly<z.ZodArray<z.ZodString>>;
         title: z.ZodString;
         state: z.ZodEnum<{
             open: "open";
@@ -22,54 +127,40 @@ export declare const taskMutationResultSchema: z.ZodUnion<readonly [z.ZodPipe<z.
             drop: "drop";
         }>;
         priority: z.ZodUnion<readonly [z.ZodLiteral<0>, z.ZodLiteral<1>, z.ZodLiteral<2>, z.ZodLiteral<3>]>;
-        needs: z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<`task/${string}`, string>>>;
+        needs: z.ZodReadonly<z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<`task/${string}`, string>>>>;
         parent: z.ZodNullable<z.ZodPipe<z.ZodString, z.ZodTransform<`task/${string}`, string>>>;
-        supersedes: z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<`task/${string}`, string>>>;
-        relates: z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<`task/${string}`, string>>>;
+        supersedes: z.ZodReadonly<z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<`task/${string}`, string>>>>;
+        relates: z.ZodReadonly<z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<`task/${string}`, string>>>>;
         note: z.ZodString;
         createdBy: z.ZodOptional<z.ZodString>;
         createdAt: z.ZodString;
         updatedAt: z.ZodString;
         body: z.ZodString;
-    }, z.core.$strict>, z.ZodTransform<{
+    }, z.core.$strict>, z.ZodTransform<WithoutUndefined<{
+        createdBy: string | undefined;
         id: `task/${string}`;
-        namespace: string[];
+        namespace: readonly string[];
         title: string;
         state: "open" | "in_progress" | "on_hold" | "done" | "drop";
         priority: 0 | 1 | 2 | 3;
-        needs: `task/${string}`[];
+        needs: readonly `task/${string}`[];
         parent: `task/${string}` | null;
-        supersedes: `task/${string}`[];
-        relates: `task/${string}`[];
+        supersedes: readonly `task/${string}`[];
+        relates: readonly `task/${string}`[];
         note: string;
         createdAt: string;
         updatedAt: string;
         body: string;
-    } | {
-        createdBy: string;
+    }>, {
         id: `task/${string}`;
-        namespace: string[];
+        namespace: readonly string[];
         title: string;
         state: "open" | "in_progress" | "on_hold" | "done" | "drop";
         priority: 0 | 1 | 2 | 3;
-        needs: `task/${string}`[];
+        needs: readonly `task/${string}`[];
         parent: `task/${string}` | null;
-        supersedes: `task/${string}`[];
-        relates: `task/${string}`[];
-        note: string;
-        createdAt: string;
-        updatedAt: string;
-        body: string;
-    }, {
-        id: `task/${string}`;
-        namespace: string[];
-        title: string;
-        state: "open" | "in_progress" | "on_hold" | "done" | "drop";
-        priority: 0 | 1 | 2 | 3;
-        needs: `task/${string}`[];
-        parent: `task/${string}` | null;
-        supersedes: `task/${string}`[];
-        relates: `task/${string}`[];
+        supersedes: readonly `task/${string}`[];
+        relates: readonly `task/${string}`[];
         note: string;
         createdAt: string;
         updatedAt: string;
@@ -78,79 +169,51 @@ export declare const taskMutationResultSchema: z.ZodUnion<readonly [z.ZodPipe<z.
     }>>;
     cleanup: z.ZodOptional<z.ZodObject<{
         kind: z.ZodLiteral<"lock-release-failed">;
-        diagnostics: z.ZodArray<z.ZodString>;
+        diagnostics: z.ZodReadonly<z.ZodArray<z.ZodString>>;
     }, z.core.$strict>>;
 }, z.core.$strict>, z.ZodTransform<WithoutUndefined<{
     kind: "accepted";
-    value: {
+    value: WithoutUndefined<{
+        createdBy: string | undefined;
         id: `task/${string}`;
-        namespace: string[];
+        namespace: readonly string[];
         title: string;
         state: "open" | "in_progress" | "on_hold" | "done" | "drop";
         priority: 0 | 1 | 2 | 3;
-        needs: `task/${string}`[];
+        needs: readonly `task/${string}`[];
         parent: `task/${string}` | null;
-        supersedes: `task/${string}`[];
-        relates: `task/${string}`[];
+        supersedes: readonly `task/${string}`[];
+        relates: readonly `task/${string}`[];
         note: string;
         createdAt: string;
         updatedAt: string;
         body: string;
-    } | {
-        createdBy: string;
-        id: `task/${string}`;
-        namespace: string[];
-        title: string;
-        state: "open" | "in_progress" | "on_hold" | "done" | "drop";
-        priority: 0 | 1 | 2 | 3;
-        needs: `task/${string}`[];
-        parent: `task/${string}` | null;
-        supersedes: `task/${string}`[];
-        relates: `task/${string}`[];
-        note: string;
-        createdAt: string;
-        updatedAt: string;
-        body: string;
-    };
+    }>;
     cleanup?: {
         kind: "lock-release-failed";
-        diagnostics: string[];
+        diagnostics: readonly string[];
     } | undefined;
 }>, {
     kind: "accepted";
-    value: {
+    value: WithoutUndefined<{
+        createdBy: string | undefined;
         id: `task/${string}`;
-        namespace: string[];
+        namespace: readonly string[];
         title: string;
         state: "open" | "in_progress" | "on_hold" | "done" | "drop";
         priority: 0 | 1 | 2 | 3;
-        needs: `task/${string}`[];
+        needs: readonly `task/${string}`[];
         parent: `task/${string}` | null;
-        supersedes: `task/${string}`[];
-        relates: `task/${string}`[];
+        supersedes: readonly `task/${string}`[];
+        relates: readonly `task/${string}`[];
         note: string;
         createdAt: string;
         updatedAt: string;
         body: string;
-    } | {
-        createdBy: string;
-        id: `task/${string}`;
-        namespace: string[];
-        title: string;
-        state: "open" | "in_progress" | "on_hold" | "done" | "drop";
-        priority: 0 | 1 | 2 | 3;
-        needs: `task/${string}`[];
-        parent: `task/${string}` | null;
-        supersedes: `task/${string}`[];
-        relates: `task/${string}`[];
-        note: string;
-        createdAt: string;
-        updatedAt: string;
-        body: string;
-    };
+    }>;
     cleanup?: {
         kind: "lock-release-failed";
-        diagnostics: string[];
+        diagnostics: readonly string[];
     } | undefined;
 }>>, z.ZodObject<{
     kind: z.ZodLiteral<"refused">;
@@ -188,11 +251,11 @@ export declare const taskMutationResultSchema: z.ZodUnion<readonly [z.ZodPipe<z.
         declaringTask: z.ZodPipe<z.ZodString, z.ZodTransform<`task/${string}`, string>>;
     }, z.core.$strict>, z.ZodObject<{
         kind: z.ZodLiteral<"invalid-composition">;
-        diagnostics: z.ZodArray<z.ZodObject<{
+        diagnostics: z.ZodReadonly<z.ZodArray<z.ZodObject<{
             line: z.ZodNumber;
             reason: z.ZodString;
             token: z.ZodString;
-        }, z.core.$strict>>;
+        }, z.core.$strict>>>;
     }, z.core.$strict>]>;
 }, z.core.$strict>, z.ZodObject<{
     kind: z.ZodLiteral<"retry">;
@@ -206,7 +269,7 @@ export declare const taskUpdateResultSchema: z.ZodUnion<readonly [z.ZodPipe<z.Zo
     value: z.ZodObject<{
         task: z.ZodPipe<z.ZodObject<{
             id: z.ZodPipe<z.ZodString, z.ZodTransform<`task/${string}`, string>>;
-            namespace: z.ZodArray<z.ZodString>;
+            namespace: z.ZodReadonly<z.ZodArray<z.ZodString>>;
             title: z.ZodString;
             state: z.ZodEnum<{
                 open: "open";
@@ -216,54 +279,40 @@ export declare const taskUpdateResultSchema: z.ZodUnion<readonly [z.ZodPipe<z.Zo
                 drop: "drop";
             }>;
             priority: z.ZodUnion<readonly [z.ZodLiteral<0>, z.ZodLiteral<1>, z.ZodLiteral<2>, z.ZodLiteral<3>]>;
-            needs: z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<`task/${string}`, string>>>;
+            needs: z.ZodReadonly<z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<`task/${string}`, string>>>>;
             parent: z.ZodNullable<z.ZodPipe<z.ZodString, z.ZodTransform<`task/${string}`, string>>>;
-            supersedes: z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<`task/${string}`, string>>>;
-            relates: z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<`task/${string}`, string>>>;
+            supersedes: z.ZodReadonly<z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<`task/${string}`, string>>>>;
+            relates: z.ZodReadonly<z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<`task/${string}`, string>>>>;
             note: z.ZodString;
             createdBy: z.ZodOptional<z.ZodString>;
             createdAt: z.ZodString;
             updatedAt: z.ZodString;
             body: z.ZodString;
-        }, z.core.$strict>, z.ZodTransform<{
-            id: `task/${string}`;
-            namespace: string[];
-            title: string;
-            state: "open" | "in_progress" | "on_hold" | "done" | "drop";
-            priority: 0 | 1 | 2 | 3;
-            needs: `task/${string}`[];
-            parent: `task/${string}` | null;
-            supersedes: `task/${string}`[];
-            relates: `task/${string}`[];
-            note: string;
-            createdAt: string;
-            updatedAt: string;
-            body: string;
-        } | {
-            createdBy: string;
+        }, z.core.$strict>, z.ZodTransform<WithoutUndefined<{
+            createdBy: string | undefined;
             id: `task/${string}`;
-            namespace: string[];
+            namespace: readonly string[];
             title: string;
             state: "open" | "in_progress" | "on_hold" | "done" | "drop";
             priority: 0 | 1 | 2 | 3;
-            needs: `task/${string}`[];
+            needs: readonly `task/${string}`[];
             parent: `task/${string}` | null;
-            supersedes: `task/${string}`[];
-            relates: `task/${string}`[];
+            supersedes: readonly `task/${string}`[];
+            relates: readonly `task/${string}`[];
             note: string;
             createdAt: string;
             updatedAt: string;
             body: string;
-        }, {
+        }>, {
             id: `task/${string}`;
-            namespace: string[];
+            namespace: readonly string[];
             title: string;
             state: "open" | "in_progress" | "on_hold" | "done" | "drop";
             priority: 0 | 1 | 2 | 3;
-            needs: `task/${string}`[];
+            needs: readonly `task/${string}`[];
             parent: `task/${string}` | null;
-            supersedes: `task/${string}`[];
-            relates: `task/${string}`[];
+            supersedes: readonly `task/${string}`[];
+            relates: readonly `task/${string}`[];
             note: string;
             createdAt: string;
             updatedAt: string;
@@ -271,88 +320,78 @@ export declare const taskUpdateResultSchema: z.ZodUnion<readonly [z.ZodPipe<z.Zo
             createdBy?: string | undefined;
         }>>;
         documentDiff: z.ZodString;
+        changedFields: z.ZodReadonly<z.ZodArray<z.ZodObject<{
+            field: z.ZodString;
+            action: z.ZodEnum<{
+                replaced: "replaced";
+                changed: "changed";
+                added: "added";
+                cleared: "cleared";
+                appended: "appended";
+            }>;
+        }, z.core.$strict>>>;
     }, z.core.$strict>;
     cleanup: z.ZodOptional<z.ZodObject<{
         kind: z.ZodLiteral<"lock-release-failed">;
-        diagnostics: z.ZodArray<z.ZodString>;
+        diagnostics: z.ZodReadonly<z.ZodArray<z.ZodString>>;
     }, z.core.$strict>>;
 }, z.core.$strict>, z.ZodTransform<WithoutUndefined<{
     kind: "accepted";
     value: {
-        task: {
-            id: `task/${string}`;
-            namespace: string[];
-            title: string;
-            state: "open" | "in_progress" | "on_hold" | "done" | "drop";
-            priority: 0 | 1 | 2 | 3;
-            needs: `task/${string}`[];
-            parent: `task/${string}` | null;
-            supersedes: `task/${string}`[];
-            relates: `task/${string}`[];
-            note: string;
-            createdAt: string;
-            updatedAt: string;
-            body: string;
-        } | {
-            createdBy: string;
+        task: WithoutUndefined<{
+            createdBy: string | undefined;
             id: `task/${string}`;
-            namespace: string[];
+            namespace: readonly string[];
             title: string;
             state: "open" | "in_progress" | "on_hold" | "done" | "drop";
             priority: 0 | 1 | 2 | 3;
-            needs: `task/${string}`[];
+            needs: readonly `task/${string}`[];
             parent: `task/${string}` | null;
-            supersedes: `task/${string}`[];
-            relates: `task/${string}`[];
+            supersedes: readonly `task/${string}`[];
+            relates: readonly `task/${string}`[];
             note: string;
             createdAt: string;
             updatedAt: string;
             body: string;
-        };
+        }>;
         documentDiff: string;
+        changedFields: readonly {
+            field: string;
+            action: "replaced" | "changed" | "added" | "cleared" | "appended";
+        }[];
     };
     cleanup?: {
         kind: "lock-release-failed";
-        diagnostics: string[];
+        diagnostics: readonly string[];
     } | undefined;
 }>, {
     kind: "accepted";
     value: {
-        task: {
+        task: WithoutUndefined<{
+            createdBy: string | undefined;
             id: `task/${string}`;
-            namespace: string[];
+            namespace: readonly string[];
             title: string;
             state: "open" | "in_progress" | "on_hold" | "done" | "drop";
             priority: 0 | 1 | 2 | 3;
-            needs: `task/${string}`[];
+            needs: readonly `task/${string}`[];
             parent: `task/${string}` | null;
-            supersedes: `task/${string}`[];
-            relates: `task/${string}`[];
+            supersedes: readonly `task/${string}`[];
+            relates: readonly `task/${string}`[];
             note: string;
             createdAt: string;
             updatedAt: string;
             body: string;
-        } | {
-            createdBy: string;
-            id: `task/${string}`;
-            namespace: string[];
-            title: string;
-            state: "open" | "in_progress" | "on_hold" | "done" | "drop";
-            priority: 0 | 1 | 2 | 3;
-            needs: `task/${string}`[];
-            parent: `task/${string}` | null;
-            supersedes: `task/${string}`[];
-            relates: `task/${string}`[];
-            note: string;
-            createdAt: string;
-            updatedAt: string;
-            body: string;
-        };
+        }>;
         documentDiff: string;
+        changedFields: readonly {
+            field: string;
+            action: "replaced" | "changed" | "added" | "cleared" | "appended";
+        }[];
     };
     cleanup?: {
         kind: "lock-release-failed";
-        diagnostics: string[];
+        diagnostics: readonly string[];
     } | undefined;
 }>>, z.ZodObject<{
     kind: z.ZodLiteral<"refused">;
@@ -390,11 +429,11 @@ export declare const taskUpdateResultSchema: z.ZodUnion<readonly [z.ZodPipe<z.Zo
         declaringTask: z.ZodPipe<z.ZodString, z.ZodTransform<`task/${string}`, string>>;
     }, z.core.$strict>, z.ZodObject<{
         kind: z.ZodLiteral<"invalid-composition">;
-        diagnostics: z.ZodArray<z.ZodObject<{
+        diagnostics: z.ZodReadonly<z.ZodArray<z.ZodObject<{
             line: z.ZodNumber;
             reason: z.ZodString;
             token: z.ZodString;
-        }, z.core.$strict>>;
+        }, z.core.$strict>>>;
     }, z.core.$strict>]>;
 }, z.core.$strict>, z.ZodObject<{
     kind: z.ZodLiteral<"retry">;
@@ -404,13 +443,13 @@ export declare const taskUpdateResultSchema: z.ZodUnion<readonly [z.ZodPipe<z.Zo
     }>;
 }, z.core.$strict>]>;
 export declare const taskBatchResultSchema: z.ZodObject<{
-    items: z.ZodArray<z.ZodObject<{
+    items: z.ZodReadonly<z.ZodArray<z.ZodObject<{
         id: z.ZodPipe<z.ZodString, z.ZodTransform<`task/${string}`, string>>;
         outcome: z.ZodUnion<readonly [z.ZodPipe<z.ZodObject<{
             kind: z.ZodLiteral<"accepted">;
             value: z.ZodPipe<z.ZodObject<{
                 id: z.ZodPipe<z.ZodString, z.ZodTransform<`task/${string}`, string>>;
-                namespace: z.ZodArray<z.ZodString>;
+                namespace: z.ZodReadonly<z.ZodArray<z.ZodString>>;
                 title: z.ZodString;
                 state: z.ZodEnum<{
                     open: "open";
@@ -420,54 +459,40 @@ export declare const taskBatchResultSchema: z.ZodObject<{
                     drop: "drop";
                 }>;
                 priority: z.ZodUnion<readonly [z.ZodLiteral<0>, z.ZodLiteral<1>, z.ZodLiteral<2>, z.ZodLiteral<3>]>;
-                needs: z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<`task/${string}`, string>>>;
+                needs: z.ZodReadonly<z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<`task/${string}`, string>>>>;
                 parent: z.ZodNullable<z.ZodPipe<z.ZodString, z.ZodTransform<`task/${string}`, string>>>;
-                supersedes: z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<`task/${string}`, string>>>;
-                relates: z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<`task/${string}`, string>>>;
+                supersedes: z.ZodReadonly<z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<`task/${string}`, string>>>>;
+                relates: z.ZodReadonly<z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<`task/${string}`, string>>>>;
                 note: z.ZodString;
                 createdBy: z.ZodOptional<z.ZodString>;
                 createdAt: z.ZodString;
                 updatedAt: z.ZodString;
                 body: z.ZodString;
-            }, z.core.$strict>, z.ZodTransform<{
+            }, z.core.$strict>, z.ZodTransform<WithoutUndefined<{
+                createdBy: string | undefined;
                 id: `task/${string}`;
-                namespace: string[];
+                namespace: readonly string[];
                 title: string;
                 state: "open" | "in_progress" | "on_hold" | "done" | "drop";
                 priority: 0 | 1 | 2 | 3;
-                needs: `task/${string}`[];
+                needs: readonly `task/${string}`[];
                 parent: `task/${string}` | null;
-                supersedes: `task/${string}`[];
-                relates: `task/${string}`[];
+                supersedes: readonly `task/${string}`[];
+                relates: readonly `task/${string}`[];
                 note: string;
                 createdAt: string;
                 updatedAt: string;
                 body: string;
-            } | {
-                createdBy: string;
+            }>, {
                 id: `task/${string}`;
-                namespace: string[];
+                namespace: readonly string[];
                 title: string;
                 state: "open" | "in_progress" | "on_hold" | "done" | "drop";
                 priority: 0 | 1 | 2 | 3;
-                needs: `task/${string}`[];
+                needs: readonly `task/${string}`[];
                 parent: `task/${string}` | null;
-                supersedes: `task/${string}`[];
-                relates: `task/${string}`[];
-                note: string;
-                createdAt: string;
-                updatedAt: string;
-                body: string;
-            }, {
-                id: `task/${string}`;
-                namespace: string[];
-                title: string;
-                state: "open" | "in_progress" | "on_hold" | "done" | "drop";
-                priority: 0 | 1 | 2 | 3;
-                needs: `task/${string}`[];
-                parent: `task/${string}` | null;
-                supersedes: `task/${string}`[];
-                relates: `task/${string}`[];
+                supersedes: readonly `task/${string}`[];
+                relates: readonly `task/${string}`[];
                 note: string;
                 createdAt: string;
                 updatedAt: string;
@@ -476,79 +501,51 @@ export declare const taskBatchResultSchema: z.ZodObject<{
             }>>;
             cleanup: z.ZodOptional<z.ZodObject<{
                 kind: z.ZodLiteral<"lock-release-failed">;
-                diagnostics: z.ZodArray<z.ZodString>;
+                diagnostics: z.ZodReadonly<z.ZodArray<z.ZodString>>;
             }, z.core.$strict>>;
         }, z.core.$strict>, z.ZodTransform<WithoutUndefined<{
             kind: "accepted";
-            value: {
+            value: WithoutUndefined<{
+                createdBy: string | undefined;
                 id: `task/${string}`;
-                namespace: string[];
+                namespace: readonly string[];
                 title: string;
                 state: "open" | "in_progress" | "on_hold" | "done" | "drop";
                 priority: 0 | 1 | 2 | 3;
-                needs: `task/${string}`[];
+                needs: readonly `task/${string}`[];
                 parent: `task/${string}` | null;
-                supersedes: `task/${string}`[];
-                relates: `task/${string}`[];
+                supersedes: readonly `task/${string}`[];
+                relates: readonly `task/${string}`[];
                 note: string;
                 createdAt: string;
                 updatedAt: string;
                 body: string;
-            } | {
-                createdBy: string;
-                id: `task/${string}`;
-                namespace: string[];
-                title: string;
-                state: "open" | "in_progress" | "on_hold" | "done" | "drop";
-                priority: 0 | 1 | 2 | 3;
-                needs: `task/${string}`[];
-                parent: `task/${string}` | null;
-                supersedes: `task/${string}`[];
-                relates: `task/${string}`[];
-                note: string;
-                createdAt: string;
-                updatedAt: string;
-                body: string;
-            };
+            }>;
             cleanup?: {
                 kind: "lock-release-failed";
-                diagnostics: string[];
+                diagnostics: readonly string[];
             } | undefined;
         }>, {
             kind: "accepted";
-            value: {
-                id: `task/${string}`;
-                namespace: string[];
-                title: string;
-                state: "open" | "in_progress" | "on_hold" | "done" | "drop";
-                priority: 0 | 1 | 2 | 3;
-                needs: `task/${string}`[];
-                parent: `task/${string}` | null;
-                supersedes: `task/${string}`[];
-                relates: `task/${string}`[];
-                note: string;
-                createdAt: string;
-                updatedAt: string;
-                body: string;
-            } | {
-                createdBy: string;
+            value: WithoutUndefined<{
+                createdBy: string | undefined;
                 id: `task/${string}`;
-                namespace: string[];
+                namespace: readonly string[];
                 title: string;
                 state: "open" | "in_progress" | "on_hold" | "done" | "drop";
                 priority: 0 | 1 | 2 | 3;
-                needs: `task/${string}`[];
+                needs: readonly `task/${string}`[];
                 parent: `task/${string}` | null;
-                supersedes: `task/${string}`[];
-                relates: `task/${string}`[];
+                supersedes: readonly `task/${string}`[];
+                relates: readonly `task/${string}`[];
                 note: string;
                 createdAt: string;
                 updatedAt: string;
                 body: string;
-            };
+            }>;
             cleanup?: {
                 kind: "lock-release-failed";
-                diagnostics: string[];
+                diagnostics: readonly string[];
             } | undefined;
         }>>, z.ZodObject<{
             kind: z.ZodLiteral<"refused">;
@@ -586,11 +583,11 @@ export declare const taskBatchResultSchema: z.ZodObject<{
                 declaringTask: z.ZodPipe<z.ZodString, z.ZodTransform<`task/${string}`, string>>;
             }, z.core.$strict>, z.ZodObject<{
                 kind: z.ZodLiteral<"invalid-composition">;
-                diagnostics: z.ZodArray<z.ZodObject<{
+                diagnostics: z.ZodReadonly<z.ZodArray<z.ZodObject<{
                     line: z.ZodNumber;
                     reason: z.ZodString;
                     token: z.ZodString;
-                }, z.core.$strict>>;
+                }, z.core.$strict>>>;
             }, z.core.$strict>]>;
         }, z.core.$strict>, z.ZodObject<{
             kind: z.ZodLiteral<"retry">;
@@ -599,94 +596,143 @@ export declare const taskBatchResultSchema: z.ZodObject<{
                 busy: "busy";
             }>;
         }, z.core.$strict>]>;
-    }, z.core.$strict>>;
+    }, z.core.$strict>>>;
 }, z.core.$strict>;
 export declare const taskCompositionResultSchema: z.ZodUnion<readonly [z.ZodObject<{
-    bodies: z.ZodArray<z.ZodObject<{
+    kind: z.ZodLiteral<"planned">;
+    aliases: z.ZodReadonly<z.ZodArray<z.ZodObject<{
+        alias: z.ZodString;
+        position: z.ZodNumber;
+    }, z.core.$strict>>>;
+    admissionOrder: z.ZodReadonly<z.ZodArray<z.ZodObject<{
+        position: z.ZodNumber;
+        alias: z.ZodOptional<z.ZodString>;
+        taskId: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<`task/${string}`, string>>>;
+    }, z.core.$strict>>>;
+    admissions: z.ZodReadonly<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"new">;
+        position: z.ZodNumber;
+        alias: z.ZodOptional<z.ZodString>;
+        title: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"existing">;
+        position: z.ZodNumber;
         taskId: z.ZodPipe<z.ZodString, z.ZodTransform<`task/${string}`, string>>;
+        title: z.ZodString;
+    }, z.core.$strict>], "kind">>>;
+    bodies: z.ZodReadonly<z.ZodArray<z.ZodObject<{
+        position: z.ZodNumber;
+        title: z.ZodString;
         bytes: z.ZodNumber;
         firstLine: z.ZodString;
         lastLine: z.ZodString;
-    }, z.core.$strict>>;
-    aliases: z.ZodArray<z.ZodObject<{
-        alias: z.ZodString;
-        taskId: z.ZodPipe<z.ZodString, z.ZodTransform<`task/${string}`, string>>;
-    }, z.core.$strict>>;
-    admissionOrder: z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<`task/${string}`, string>>>;
-    kind: z.ZodLiteral<"planned">;
+    }, z.core.$strict>>>;
 }, z.core.$strict>, z.ZodPipe<z.ZodObject<{
-    documentChanges: z.ZodArray<z.ZodObject<{
+    documentChanges: z.ZodReadonly<z.ZodArray<z.ZodObject<{
         taskId: z.ZodPipe<z.ZodString, z.ZodTransform<`task/${string}`, string>>;
         kind: z.ZodEnum<{
             created: "created";
             updated: "updated";
         }>;
         documentDiff: z.ZodString;
-    }, z.core.$strict>>;
+    }, z.core.$strict>>>;
     cleanup: z.ZodOptional<z.ZodObject<{
         kind: z.ZodLiteral<"lock-release-failed">;
-        diagnostics: z.ZodArray<z.ZodString>;
+        diagnostics: z.ZodReadonly<z.ZodArray<z.ZodString>>;
     }, z.core.$strict>>;
-    aliases: z.ZodArray<z.ZodObject<{
+    aliases: z.ZodReadonly<z.ZodArray<z.ZodObject<{
         alias: z.ZodString;
         taskId: z.ZodPipe<z.ZodString, z.ZodTransform<`task/${string}`, string>>;
-    }, z.core.$strict>>;
-    admissionOrder: z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<`task/${string}`, string>>>;
+    }, z.core.$strict>>>;
+    admissionOrder: z.ZodReadonly<z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<`task/${string}`, string>>>>;
+    admissions: z.ZodReadonly<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"new">;
+        position: z.ZodNumber;
+        alias: z.ZodOptional<z.ZodString>;
+        title: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"existing">;
+        position: z.ZodNumber;
+        taskId: z.ZodPipe<z.ZodString, z.ZodTransform<`task/${string}`, string>>;
+        title: z.ZodString;
+    }, z.core.$strict>], "kind">>>;
     kind: z.ZodLiteral<"accepted">;
 }, z.core.$strict>, z.ZodTransform<WithoutUndefined<{
-    documentChanges: {
+    documentChanges: readonly {
         taskId: `task/${string}`;
         kind: "created" | "updated";
         documentDiff: string;
     }[];
-    aliases: {
+    aliases: readonly {
         alias: string;
         taskId: `task/${string}`;
     }[];
-    admissionOrder: `task/${string}`[];
+    admissionOrder: readonly `task/${string}`[];
+    admissions: readonly ({
+        kind: "new";
+        position: number;
+        title: string;
+        alias?: string | undefined;
+    } | {
+        kind: "existing";
+        position: number;
+        taskId: `task/${string}`;
+        title: string;
+    })[];
     kind: "accepted";
     cleanup?: {
         kind: "lock-release-failed";
-        diagnostics: string[];
+        diagnostics: readonly string[];
     } | undefined;
 }>, {
-    documentChanges: {
+    documentChanges: readonly {
         taskId: `task/${string}`;
         kind: "created" | "updated";
         documentDiff: string;
     }[];
-    aliases: {
+    aliases: readonly {
         alias: string;
         taskId: `task/${string}`;
     }[];
-    admissionOrder: `task/${string}`[];
+    admissionOrder: readonly `task/${string}`[];
+    admissions: readonly ({
+        kind: "new";
+        position: number;
+        title: string;
+        alias?: string | undefined;
+    } | {
+        kind: "existing";
+        position: number;
+        taskId: `task/${string}`;
+        title: string;
+    })[];
     kind: "accepted";
     cleanup?: {
         kind: "lock-release-failed";
-        diagnostics: string[];
+        diagnostics: readonly string[];
     } | undefined;
 }>>, z.ZodObject<{
     kind: z.ZodLiteral<"refused">;
     refusal: z.ZodObject<{
         kind: z.ZodLiteral<"invalid-composition">;
-        diagnostics: z.ZodArray<z.ZodObject<{
+        diagnostics: z.ZodReadonly<z.ZodArray<z.ZodObject<{
             line: z.ZodNumber;
             reason: z.ZodString;
             token: z.ZodString;
-        }, z.core.$strict>>;
+        }, z.core.$strict>>>;
     }, z.core.$strict>;
 }, z.core.$strict>, z.ZodPipe<z.ZodObject<{
-    documentChanges: z.ZodArray<z.ZodObject<{
+    documentChanges: z.ZodReadonly<z.ZodArray<z.ZodObject<{
         taskId: z.ZodPipe<z.ZodString, z.ZodTransform<`task/${string}`, string>>;
         kind: z.ZodEnum<{
             created: "created";
             updated: "updated";
         }>;
         documentDiff: z.ZodString;
-    }, z.core.$strict>>;
+    }, z.core.$strict>>>;
     cleanup: z.ZodOptional<z.ZodObject<{
         kind: z.ZodLiteral<"lock-release-failed">;
-        diagnostics: z.ZodArray<z.ZodString>;
+        diagnostics: z.ZodReadonly<z.ZodArray<z.ZodString>>;
     }, z.core.$strict>>;
     stopped: z.ZodUnion<readonly [z.ZodUnion<readonly [z.ZodObject<{
         kind: z.ZodLiteral<"task-missing">;
@@ -722,11 +768,11 @@ export declare const taskCompositionResultSchema: z.ZodUnion<readonly [z.ZodObje
         declaringTask: z.ZodPipe<z.ZodString, z.ZodTransform<`task/${string}`, string>>;
     }, z.core.$strict>, z.ZodObject<{
         kind: z.ZodLiteral<"invalid-composition">;
-        diagnostics: z.ZodArray<z.ZodObject<{
+        diagnostics: z.ZodReadonly<z.ZodArray<z.ZodObject<{
             line: z.ZodNumber;
             reason: z.ZodString;
             token: z.ZodString;
-        }, z.core.$strict>>;
+        }, z.core.$strict>>>;
     }, z.core.$strict>]>, z.ZodObject<{
         kind: z.ZodLiteral<"retry">;
         reason: z.ZodEnum<{
@@ -735,19 +781,40 @@ export declare const taskCompositionResultSchema: z.ZodUnion<readonly [z.ZodObje
         }>;
     }, z.core.$strict>]>;
     draft: z.ZodString;
-    aliases: z.ZodArray<z.ZodObject<{
+    aliases: z.ZodReadonly<z.ZodArray<z.ZodObject<{
         alias: z.ZodString;
         taskId: z.ZodPipe<z.ZodString, z.ZodTransform<`task/${string}`, string>>;
-    }, z.core.$strict>>;
-    admissionOrder: z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<`task/${string}`, string>>>;
+    }, z.core.$strict>>>;
+    admissionOrder: z.ZodReadonly<z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<`task/${string}`, string>>>>;
+    admissions: z.ZodReadonly<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"new">;
+        position: z.ZodNumber;
+        alias: z.ZodOptional<z.ZodString>;
+        title: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"existing">;
+        position: z.ZodNumber;
+        taskId: z.ZodPipe<z.ZodString, z.ZodTransform<`task/${string}`, string>>;
+        title: z.ZodString;
+    }, z.core.$strict>], "kind">>>;
     kind: z.ZodLiteral<"incomplete">;
 }, z.core.$strict>, z.ZodTransform<WithoutUndefined<{
-    documentChanges: {
+    documentChanges: readonly {
         taskId: `task/${string}`;
         kind: "created" | "updated";
         documentDiff: string;
     }[];
     stopped: {
+        kind: "retry";
+        reason: "concurrent-modification" | "busy";
+    } | {
+        kind: "invalid-composition";
+        diagnostics: readonly {
+            line: number;
+            reason: string;
+            token: string;
+        }[];
+    } | {
         kind: "task-missing";
         taskId: `task/${string}`;
     } | {
@@ -766,35 +833,46 @@ export declare const taskCompositionResultSchema: z.ZodUnion<readonly [z.ZodObje
         taskId: `task/${string}`;
         related: `task/${string}`;
         declaringTask: `task/${string}`;
-    } | {
-        kind: "invalid-composition";
-        diagnostics: {
-            line: number;
-            reason: string;
-            token: string;
-        }[];
-    } | {
-        kind: "retry";
-        reason: "concurrent-modification" | "busy";
     };
     draft: string;
-    aliases: {
+    aliases: readonly {
         alias: string;
         taskId: `task/${string}`;
     }[];
-    admissionOrder: `task/${string}`[];
+    admissionOrder: readonly `task/${string}`[];
+    admissions: readonly ({
+        kind: "new";
+        position: number;
+        title: string;
+        alias?: string | undefined;
+    } | {
+        kind: "existing";
+        position: number;
+        taskId: `task/${string}`;
+        title: string;
+    })[];
     kind: "incomplete";
     cleanup?: {
         kind: "lock-release-failed";
-        diagnostics: string[];
+        diagnostics: readonly string[];
     } | undefined;
 }>, {
-    documentChanges: {
+    documentChanges: readonly {
         taskId: `task/${string}`;
         kind: "created" | "updated";
         documentDiff: string;
     }[];
     stopped: {
+        kind: "retry";
+        reason: "concurrent-modification" | "busy";
+    } | {
+        kind: "invalid-composition";
+        diagnostics: readonly {
+            line: number;
+            reason: string;
+            token: string;
+        }[];
+    } | {
         kind: "task-missing";
         taskId: `task/${string}`;
     } | {
@@ -813,37 +891,38 @@ export declare const taskCompositionResultSchema: z.ZodUnion<readonly [z.ZodObje
         taskId: `task/${string}`;
         related: `task/${string}`;
         declaringTask: `task/${string}`;
-    } | {
-        kind: "invalid-composition";
-        diagnostics: {
-            line: number;
-            reason: string;
-            token: string;
-        }[];
-    } | {
-        kind: "retry";
-        reason: "concurrent-modification" | "busy";
     };
     draft: string;
-    aliases: {
+    aliases: readonly {
         alias: string;
         taskId: `task/${string}`;
     }[];
-    admissionOrder: `task/${string}`[];
+    admissionOrder: readonly `task/${string}`[];
+    admissions: readonly ({
+        kind: "new";
+        position: number;
+        title: string;
+        alias?: string | undefined;
+    } | {
+        kind: "existing";
+        position: number;
+        taskId: `task/${string}`;
+        title: string;
+    })[];
     kind: "incomplete";
     cleanup?: {
         kind: "lock-release-failed";
-        diagnostics: string[];
+        diagnostics: readonly string[];
     } | undefined;
 }>>]>;
 export declare const taskMutationExecutionResultSchema: z.ZodUnion<readonly [z.ZodObject<{
-    items: z.ZodArray<z.ZodObject<{
+    items: z.ZodReadonly<z.ZodArray<z.ZodObject<{
         id: z.ZodPipe<z.ZodString, z.ZodTransform<`task/${string}`, string>>;
         outcome: z.ZodUnion<readonly [z.ZodPipe<z.ZodObject<{
             kind: z.ZodLiteral<"accepted">;
             value: z.ZodPipe<z.ZodObject<{
                 id: z.ZodPipe<z.ZodString, z.ZodTransform<`task/${string}`, string>>;
-                namespace: z.ZodArray<z.ZodString>;
+                namespace: z.ZodReadonly<z.ZodArray<z.ZodString>>;
                 title: z.ZodString;
                 state: z.ZodEnum<{
                     open: "open";
@@ -853,54 +932,40 @@ export declare const taskMutationExecutionResultSchema: z.ZodUnion<readonly [z.Z
                     drop: "drop";
                 }>;
                 priority: z.ZodUnion<readonly [z.ZodLiteral<0>, z.ZodLiteral<1>, z.ZodLiteral<2>, z.ZodLiteral<3>]>;
-                needs: z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<`task/${string}`, string>>>;
+                needs: z.ZodReadonly<z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<`task/${string}`, string>>>>;
                 parent: z.ZodNullable<z.ZodPipe<z.ZodString, z.ZodTransform<`task/${string}`, string>>>;
-                supersedes: z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<`task/${string}`, string>>>;
-                relates: z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<`task/${string}`, string>>>;
+                supersedes: z.ZodReadonly<z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<`task/${string}`, string>>>>;
+                relates: z.ZodReadonly<z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<`task/${string}`, string>>>>;
                 note: z.ZodString;
                 createdBy: z.ZodOptional<z.ZodString>;
                 createdAt: z.ZodString;
                 updatedAt: z.ZodString;
                 body: z.ZodString;
-            }, z.core.$strict>, z.ZodTransform<{
+            }, z.core.$strict>, z.ZodTransform<WithoutUndefined<{
+                createdBy: string | undefined;
                 id: `task/${string}`;
-                namespace: string[];
+                namespace: readonly string[];
                 title: string;
                 state: "open" | "in_progress" | "on_hold" | "done" | "drop";
                 priority: 0 | 1 | 2 | 3;
-                needs: `task/${string}`[];
+                needs: readonly `task/${string}`[];
                 parent: `task/${string}` | null;
-                supersedes: `task/${string}`[];
-                relates: `task/${string}`[];
+                supersedes: readonly `task/${string}`[];
+                relates: readonly `task/${string}`[];
                 note: string;
                 createdAt: string;
                 updatedAt: string;
                 body: string;
-            } | {
-                createdBy: string;
+            }>, {
                 id: `task/${string}`;
-                namespace: string[];
+                namespace: readonly string[];
                 title: string;
                 state: "open" | "in_progress" | "on_hold" | "done" | "drop";
                 priority: 0 | 1 | 2 | 3;
-                needs: `task/${string}`[];
+                needs: readonly `task/${string}`[];
                 parent: `task/${string}` | null;
-                supersedes: `task/${string}`[];
-                relates: `task/${string}`[];
-                note: string;
-                createdAt: string;
-                updatedAt: string;
-                body: string;
-            }, {
-                id: `task/${string}`;
-                namespace: string[];
-                title: string;
-                state: "open" | "in_progress" | "on_hold" | "done" | "drop";
-                priority: 0 | 1 | 2 | 3;
-                needs: `task/${string}`[];
-                parent: `task/${string}` | null;
-                supersedes: `task/${string}`[];
-                relates: `task/${string}`[];
+                supersedes: readonly `task/${string}`[];
+                relates: readonly `task/${string}`[];
                 note: string;
                 createdAt: string;
                 updatedAt: string;
@@ -909,79 +974,51 @@ export declare const taskMutationExecutionResultSchema: z.ZodUnion<readonly [z.Z
             }>>;
             cleanup: z.ZodOptional<z.ZodObject<{
                 kind: z.ZodLiteral<"lock-release-failed">;
-                diagnostics: z.ZodArray<z.ZodString>;
+                diagnostics: z.ZodReadonly<z.ZodArray<z.ZodString>>;
             }, z.core.$strict>>;
         }, z.core.$strict>, z.ZodTransform<WithoutUndefined<{
             kind: "accepted";
-            value: {
-                id: `task/${string}`;
-                namespace: string[];
-                title: string;
-                state: "open" | "in_progress" | "on_hold" | "done" | "drop";
-                priority: 0 | 1 | 2 | 3;
-                needs: `task/${string}`[];
-                parent: `task/${string}` | null;
-                supersedes: `task/${string}`[];
-                relates: `task/${string}`[];
-                note: string;
-                createdAt: string;
-                updatedAt: string;
-                body: string;
-            } | {
-                createdBy: string;
+            value: WithoutUndefined<{
+                createdBy: string | undefined;
                 id: `task/${string}`;
-                namespace: string[];
+                namespace: readonly string[];
                 title: string;
                 state: "open" | "in_progress" | "on_hold" | "done" | "drop";
                 priority: 0 | 1 | 2 | 3;
-                needs: `task/${string}`[];
+                needs: readonly `task/${string}`[];
                 parent: `task/${string}` | null;
-                supersedes: `task/${string}`[];
-                relates: `task/${string}`[];
+                supersedes: readonly `task/${string}`[];
+                relates: readonly `task/${string}`[];
                 note: string;
                 createdAt: string;
                 updatedAt: string;
                 body: string;
-            };
+            }>;
             cleanup?: {
                 kind: "lock-release-failed";
-                diagnostics: string[];
+                diagnostics: readonly string[];
             } | undefined;
         }>, {
             kind: "accepted";
-            value: {
+            value: WithoutUndefined<{
+                createdBy: string | undefined;
                 id: `task/${string}`;
-                namespace: string[];
+                namespace: readonly string[];
                 title: string;
                 state: "open" | "in_progress" | "on_hold" | "done" | "drop";
                 priority: 0 | 1 | 2 | 3;
-                needs: `task/${string}`[];
+                needs: readonly `task/${string}`[];
                 parent: `task/${string}` | null;
-                supersedes: `task/${string}`[];
-                relates: `task/${string}`[];
+                supersedes: readonly `task/${string}`[];
+                relates: readonly `task/${string}`[];
                 note: string;
                 createdAt: string;
                 updatedAt: string;
                 body: string;
-            } | {
-                createdBy: string;
-                id: `task/${string}`;
-                namespace: string[];
-                title: string;
-                state: "open" | "in_progress" | "on_hold" | "done" | "drop";
-                priority: 0 | 1 | 2 | 3;
-                needs: `task/${string}`[];
-                parent: `task/${string}` | null;
-                supersedes: `task/${string}`[];
-                relates: `task/${string}`[];
-                note: string;
-                createdAt: string;
-                updatedAt: string;
-                body: string;
-            };
+            }>;
             cleanup?: {
                 kind: "lock-release-failed";
-                diagnostics: string[];
+                diagnostics: readonly string[];
             } | undefined;
         }>>, z.ZodObject<{
             kind: z.ZodLiteral<"refused">;
@@ -1019,11 +1056,11 @@ export declare const taskMutationExecutionResultSchema: z.ZodUnion<readonly [z.Z
                 declaringTask: z.ZodPipe<z.ZodString, z.ZodTransform<`task/${string}`, string>>;
             }, z.core.$strict>, z.ZodObject<{
                 kind: z.ZodLiteral<"invalid-composition">;
-                diagnostics: z.ZodArray<z.ZodObject<{
+                diagnostics: z.ZodReadonly<z.ZodArray<z.ZodObject<{
                     line: z.ZodNumber;
                     reason: z.ZodString;
                     token: z.ZodString;
-                }, z.core.$strict>>;
+                }, z.core.$strict>>>;
             }, z.core.$strict>]>;
         }, z.core.$strict>, z.ZodObject<{
             kind: z.ZodLiteral<"retry">;
@@ -1032,12 +1069,12 @@ export declare const taskMutationExecutionResultSchema: z.ZodUnion<readonly [z.Z
                 busy: "busy";
             }>;
         }, z.core.$strict>]>;
-    }, z.core.$strict>>;
+    }, z.core.$strict>>>;
 }, z.core.$strict>, z.ZodUnion<readonly [z.ZodPipe<z.ZodObject<{
     kind: z.ZodLiteral<"accepted">;
     value: z.ZodPipe<z.ZodObject<{
         id: z.ZodPipe<z.ZodString, z.ZodTransform<`task/${string}`, string>>;
-        namespace: z.ZodArray<z.ZodString>;
+        namespace: z.ZodReadonly<z.ZodArray<z.ZodString>>;
         title: z.ZodString;
         state: z.ZodEnum<{
             open: "open";
@@ -1047,54 +1084,40 @@ export declare const taskMutationExecutionResultSchema: z.ZodUnion<readonly [z.Z
             drop: "drop";
         }>;
         priority: z.ZodUnion<readonly [z.ZodLiteral<0>, z.ZodLiteral<1>, z.ZodLiteral<2>, z.ZodLiteral<3>]>;
-        needs: z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<`task/${string}`, string>>>;
+        needs: z.ZodReadonly<z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<`task/${string}`, string>>>>;
         parent: z.ZodNullable<z.ZodPipe<z.ZodString, z.ZodTransform<`task/${string}`, string>>>;
-        supersedes: z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<`task/${string}`, string>>>;
-        relates: z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<`task/${string}`, string>>>;
+        supersedes: z.ZodReadonly<z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<`task/${string}`, string>>>>;
+        relates: z.ZodReadonly<z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<`task/${string}`, string>>>>;
         note: z.ZodString;
         createdBy: z.ZodOptional<z.ZodString>;
         createdAt: z.ZodString;
         updatedAt: z.ZodString;
         body: z.ZodString;
-    }, z.core.$strict>, z.ZodTransform<{
-        id: `task/${string}`;
-        namespace: string[];
-        title: string;
-        state: "open" | "in_progress" | "on_hold" | "done" | "drop";
-        priority: 0 | 1 | 2 | 3;
-        needs: `task/${string}`[];
-        parent: `task/${string}` | null;
-        supersedes: `task/${string}`[];
-        relates: `task/${string}`[];
-        note: string;
-        createdAt: string;
-        updatedAt: string;
-        body: string;
-    } | {
-        createdBy: string;
+    }, z.core.$strict>, z.ZodTransform<WithoutUndefined<{
+        createdBy: string | undefined;
         id: `task/${string}`;
-        namespace: string[];
+        namespace: readonly string[];
         title: string;
         state: "open" | "in_progress" | "on_hold" | "done" | "drop";
         priority: 0 | 1 | 2 | 3;
-        needs: `task/${string}`[];
+        needs: readonly `task/${string}`[];
         parent: `task/${string}` | null;
-        supersedes: `task/${string}`[];
-        relates: `task/${string}`[];
+        supersedes: readonly `task/${string}`[];
+        relates: readonly `task/${string}`[];
         note: string;
         createdAt: string;
         updatedAt: string;
         body: string;
-    }, {
+    }>, {
         id: `task/${string}`;
-        namespace: string[];
+        namespace: readonly string[];
         title: string;
         state: "open" | "in_progress" | "on_hold" | "done" | "drop";
         priority: 0 | 1 | 2 | 3;
-        needs: `task/${string}`[];
+        needs: readonly `task/${string}`[];
         parent: `task/${string}` | null;
-        supersedes: `task/${string}`[];
-        relates: `task/${string}`[];
+        supersedes: readonly `task/${string}`[];
+        relates: readonly `task/${string}`[];
         note: string;
         createdAt: string;
         updatedAt: string;
@@ -1103,79 +1126,51 @@ export declare const taskMutationExecutionResultSchema: z.ZodUnion<readonly [z.Z
     }>>;
     cleanup: z.ZodOptional<z.ZodObject<{
         kind: z.ZodLiteral<"lock-release-failed">;
-        diagnostics: z.ZodArray<z.ZodString>;
+        diagnostics: z.ZodReadonly<z.ZodArray<z.ZodString>>;
     }, z.core.$strict>>;
 }, z.core.$strict>, z.ZodTransform<WithoutUndefined<{
     kind: "accepted";
-    value: {
+    value: WithoutUndefined<{
+        createdBy: string | undefined;
         id: `task/${string}`;
-        namespace: string[];
+        namespace: readonly string[];
         title: string;
         state: "open" | "in_progress" | "on_hold" | "done" | "drop";
         priority: 0 | 1 | 2 | 3;
-        needs: `task/${string}`[];
+        needs: readonly `task/${string}`[];
         parent: `task/${string}` | null;
-        supersedes: `task/${string}`[];
-        relates: `task/${string}`[];
+        supersedes: readonly `task/${string}`[];
+        relates: readonly `task/${string}`[];
         note: string;
         createdAt: string;
         updatedAt: string;
         body: string;
-    } | {
-        createdBy: string;
-        id: `task/${string}`;
-        namespace: string[];
-        title: string;
-        state: "open" | "in_progress" | "on_hold" | "done" | "drop";
-        priority: 0 | 1 | 2 | 3;
-        needs: `task/${string}`[];
-        parent: `task/${string}` | null;
-        supersedes: `task/${string}`[];
-        relates: `task/${string}`[];
-        note: string;
-        createdAt: string;
-        updatedAt: string;
-        body: string;
-    };
+    }>;
     cleanup?: {
         kind: "lock-release-failed";
-        diagnostics: string[];
+        diagnostics: readonly string[];
     } | undefined;
 }>, {
     kind: "accepted";
-    value: {
-        id: `task/${string}`;
-        namespace: string[];
-        title: string;
-        state: "open" | "in_progress" | "on_hold" | "done" | "drop";
-        priority: 0 | 1 | 2 | 3;
-        needs: `task/${string}`[];
-        parent: `task/${string}` | null;
-        supersedes: `task/${string}`[];
-        relates: `task/${string}`[];
-        note: string;
-        createdAt: string;
-        updatedAt: string;
-        body: string;
-    } | {
-        createdBy: string;
+    value: WithoutUndefined<{
+        createdBy: string | undefined;
         id: `task/${string}`;
-        namespace: string[];
+        namespace: readonly string[];
         title: string;
         state: "open" | "in_progress" | "on_hold" | "done" | "drop";
         priority: 0 | 1 | 2 | 3;
-        needs: `task/${string}`[];
+        needs: readonly `task/${string}`[];
         parent: `task/${string}` | null;
-        supersedes: `task/${string}`[];
-        relates: `task/${string}`[];
+        supersedes: readonly `task/${string}`[];
+        relates: readonly `task/${string}`[];
         note: string;
         createdAt: string;
         updatedAt: string;
         body: string;
-    };
+    }>;
     cleanup?: {
         kind: "lock-release-failed";
-        diagnostics: string[];
+        diagnostics: readonly string[];
     } | undefined;
 }>>, z.ZodObject<{
     kind: z.ZodLiteral<"refused">;
@@ -1213,11 +1208,11 @@ export declare const taskMutationExecutionResultSchema: z.ZodUnion<readonly [z.Z
         declaringTask: z.ZodPipe<z.ZodString, z.ZodTransform<`task/${string}`, string>>;
     }, z.core.$strict>, z.ZodObject<{
         kind: z.ZodLiteral<"invalid-composition">;
-        diagnostics: z.ZodArray<z.ZodObject<{
+        diagnostics: z.ZodReadonly<z.ZodArray<z.ZodObject<{
             line: z.ZodNumber;
             reason: z.ZodString;
             token: z.ZodString;
-        }, z.core.$strict>>;
+        }, z.core.$strict>>>;
     }, z.core.$strict>]>;
 }, z.core.$strict>, z.ZodObject<{
     kind: z.ZodLiteral<"retry">;
@@ -1230,7 +1225,7 @@ export declare const taskMutationExecutionResultSchema: z.ZodUnion<readonly [z.Z
     value: z.ZodObject<{
         task: z.ZodPipe<z.ZodObject<{
             id: z.ZodPipe<z.ZodString, z.ZodTransform<`task/${string}`, string>>;
-            namespace: z.ZodArray<z.ZodString>;
+            namespace: z.ZodReadonly<z.ZodArray<z.ZodString>>;
             title: z.ZodString;
             state: z.ZodEnum<{
                 open: "open";
@@ -1240,54 +1235,40 @@ export declare const taskMutationExecutionResultSchema: z.ZodUnion<readonly [z.Z
                 drop: "drop";
             }>;
             priority: z.ZodUnion<readonly [z.ZodLiteral<0>, z.ZodLiteral<1>, z.ZodLiteral<2>, z.ZodLiteral<3>]>;
-            needs: z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<`task/${string}`, string>>>;
+            needs: z.ZodReadonly<z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<`task/${string}`, string>>>>;
             parent: z.ZodNullable<z.ZodPipe<z.ZodString, z.ZodTransform<`task/${string}`, string>>>;
-            supersedes: z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<`task/${string}`, string>>>;
-            relates: z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<`task/${string}`, string>>>;
+            supersedes: z.ZodReadonly<z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<`task/${string}`, string>>>>;
+            relates: z.ZodReadonly<z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<`task/${string}`, string>>>>;
             note: z.ZodString;
             createdBy: z.ZodOptional<z.ZodString>;
             createdAt: z.ZodString;
             updatedAt: z.ZodString;
             body: z.ZodString;
-        }, z.core.$strict>, z.ZodTransform<{
-            id: `task/${string}`;
-            namespace: string[];
-            title: string;
-            state: "open" | "in_progress" | "on_hold" | "done" | "drop";
-            priority: 0 | 1 | 2 | 3;
-            needs: `task/${string}`[];
-            parent: `task/${string}` | null;
-            supersedes: `task/${string}`[];
-            relates: `task/${string}`[];
-            note: string;
-            createdAt: string;
-            updatedAt: string;
-            body: string;
-        } | {
-            createdBy: string;
+        }, z.core.$strict>, z.ZodTransform<WithoutUndefined<{
+            createdBy: string | undefined;
             id: `task/${string}`;
-            namespace: string[];
+            namespace: readonly string[];
             title: string;
             state: "open" | "in_progress" | "on_hold" | "done" | "drop";
             priority: 0 | 1 | 2 | 3;
-            needs: `task/${string}`[];
+            needs: readonly `task/${string}`[];
             parent: `task/${string}` | null;
-            supersedes: `task/${string}`[];
-            relates: `task/${string}`[];
+            supersedes: readonly `task/${string}`[];
+            relates: readonly `task/${string}`[];
             note: string;
             createdAt: string;
             updatedAt: string;
             body: string;
-        }, {
+        }>, {
             id: `task/${string}`;
-            namespace: string[];
+            namespace: readonly string[];
             title: string;
             state: "open" | "in_progress" | "on_hold" | "done" | "drop";
             priority: 0 | 1 | 2 | 3;
-            needs: `task/${string}`[];
+            needs: readonly `task/${string}`[];
             parent: `task/${string}` | null;
-            supersedes: `task/${string}`[];
-            relates: `task/${string}`[];
+            supersedes: readonly `task/${string}`[];
+            relates: readonly `task/${string}`[];
             note: string;
             createdAt: string;
             updatedAt: string;
@@ -1295,88 +1276,78 @@ export declare const taskMutationExecutionResultSchema: z.ZodUnion<readonly [z.Z
             createdBy?: string | undefined;
         }>>;
         documentDiff: z.ZodString;
+        changedFields: z.ZodReadonly<z.ZodArray<z.ZodObject<{
+            field: z.ZodString;
+            action: z.ZodEnum<{
+                replaced: "replaced";
+                changed: "changed";
+                added: "added";
+                cleared: "cleared";
+                appended: "appended";
+            }>;
+        }, z.core.$strict>>>;
     }, z.core.$strict>;
     cleanup: z.ZodOptional<z.ZodObject<{
         kind: z.ZodLiteral<"lock-release-failed">;
-        diagnostics: z.ZodArray<z.ZodString>;
+        diagnostics: z.ZodReadonly<z.ZodArray<z.ZodString>>;
     }, z.core.$strict>>;
 }, z.core.$strict>, z.ZodTransform<WithoutUndefined<{
     kind: "accepted";
     value: {
-        task: {
-            id: `task/${string}`;
-            namespace: string[];
-            title: string;
-            state: "open" | "in_progress" | "on_hold" | "done" | "drop";
-            priority: 0 | 1 | 2 | 3;
-            needs: `task/${string}`[];
-            parent: `task/${string}` | null;
-            supersedes: `task/${string}`[];
-            relates: `task/${string}`[];
-            note: string;
-            createdAt: string;
-            updatedAt: string;
-            body: string;
-        } | {
-            createdBy: string;
+        task: WithoutUndefined<{
+            createdBy: string | undefined;
             id: `task/${string}`;
-            namespace: string[];
+            namespace: readonly string[];
             title: string;
             state: "open" | "in_progress" | "on_hold" | "done" | "drop";
             priority: 0 | 1 | 2 | 3;
-            needs: `task/${string}`[];
+            needs: readonly `task/${string}`[];
             parent: `task/${string}` | null;
-            supersedes: `task/${string}`[];
-            relates: `task/${string}`[];
+            supersedes: readonly `task/${string}`[];
+            relates: readonly `task/${string}`[];
             note: string;
             createdAt: string;
             updatedAt: string;
             body: string;
-        };
+        }>;
         documentDiff: string;
+        changedFields: readonly {
+            field: string;
+            action: "replaced" | "changed" | "added" | "cleared" | "appended";
+        }[];
     };
     cleanup?: {
         kind: "lock-release-failed";
-        diagnostics: string[];
+        diagnostics: readonly string[];
     } | undefined;
 }>, {
     kind: "accepted";
     value: {
-        task: {
+        task: WithoutUndefined<{
+            createdBy: string | undefined;
             id: `task/${string}`;
-            namespace: string[];
+            namespace: readonly string[];
             title: string;
             state: "open" | "in_progress" | "on_hold" | "done" | "drop";
             priority: 0 | 1 | 2 | 3;
-            needs: `task/${string}`[];
+            needs: readonly `task/${string}`[];
             parent: `task/${string}` | null;
-            supersedes: `task/${string}`[];
-            relates: `task/${string}`[];
+            supersedes: readonly `task/${string}`[];
+            relates: readonly `task/${string}`[];
             note: string;
             createdAt: string;
             updatedAt: string;
             body: string;
-        } | {
-            createdBy: string;
-            id: `task/${string}`;
-            namespace: string[];
-            title: string;
-            state: "open" | "in_progress" | "on_hold" | "done" | "drop";
-            priority: 0 | 1 | 2 | 3;
-            needs: `task/${string}`[];
-            parent: `task/${string}` | null;
-            supersedes: `task/${string}`[];
-            relates: `task/${string}`[];
-            note: string;
-            createdAt: string;
-            updatedAt: string;
-            body: string;
-        };
+        }>;
         documentDiff: string;
+        changedFields: readonly {
+            field: string;
+            action: "replaced" | "changed" | "added" | "cleared" | "appended";
+        }[];
     };
     cleanup?: {
         kind: "lock-release-failed";
-        diagnostics: string[];
+        diagnostics: readonly string[];
     } | undefined;
 }>>, z.ZodObject<{
     kind: z.ZodLiteral<"refused">;
@@ -1414,11 +1385,11 @@ export declare const taskMutationExecutionResultSchema: z.ZodUnion<readonly [z.Z
         declaringTask: z.ZodPipe<z.ZodString, z.ZodTransform<`task/${string}`, string>>;
     }, z.core.$strict>, z.ZodObject<{
         kind: z.ZodLiteral<"invalid-composition">;
-        diagnostics: z.ZodArray<z.ZodObject<{
+        diagnostics: z.ZodReadonly<z.ZodArray<z.ZodObject<{
             line: z.ZodNumber;
             reason: z.ZodString;
             token: z.ZodString;
-        }, z.core.$strict>>;
+        }, z.core.$strict>>>;
     }, z.core.$strict>]>;
 }, z.core.$strict>, z.ZodObject<{
     kind: z.ZodLiteral<"retry">;
@@ -1427,91 +1398,140 @@ export declare const taskMutationExecutionResultSchema: z.ZodUnion<readonly [z.Z
         busy: "busy";
     }>;
 }, z.core.$strict>]>, z.ZodUnion<readonly [z.ZodObject<{
-    bodies: z.ZodArray<z.ZodObject<{
+    kind: z.ZodLiteral<"planned">;
+    aliases: z.ZodReadonly<z.ZodArray<z.ZodObject<{
+        alias: z.ZodString;
+        position: z.ZodNumber;
+    }, z.core.$strict>>>;
+    admissionOrder: z.ZodReadonly<z.ZodArray<z.ZodObject<{
+        position: z.ZodNumber;
+        alias: z.ZodOptional<z.ZodString>;
+        taskId: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<`task/${string}`, string>>>;
+    }, z.core.$strict>>>;
+    admissions: z.ZodReadonly<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"new">;
+        position: z.ZodNumber;
+        alias: z.ZodOptional<z.ZodString>;
+        title: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"existing">;
+        position: z.ZodNumber;
         taskId: z.ZodPipe<z.ZodString, z.ZodTransform<`task/${string}`, string>>;
+        title: z.ZodString;
+    }, z.core.$strict>], "kind">>>;
+    bodies: z.ZodReadonly<z.ZodArray<z.ZodObject<{
+        position: z.ZodNumber;
+        title: z.ZodString;
         bytes: z.ZodNumber;
         firstLine: z.ZodString;
         lastLine: z.ZodString;
-    }, z.core.$strict>>;
-    aliases: z.ZodArray<z.ZodObject<{
-        alias: z.ZodString;
-        taskId: z.ZodPipe<z.ZodString, z.ZodTransform<`task/${string}`, string>>;
-    }, z.core.$strict>>;
-    admissionOrder: z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<`task/${string}`, string>>>;
-    kind: z.ZodLiteral<"planned">;
+    }, z.core.$strict>>>;
 }, z.core.$strict>, z.ZodPipe<z.ZodObject<{
-    documentChanges: z.ZodArray<z.ZodObject<{
+    documentChanges: z.ZodReadonly<z.ZodArray<z.ZodObject<{
         taskId: z.ZodPipe<z.ZodString, z.ZodTransform<`task/${string}`, string>>;
         kind: z.ZodEnum<{
             created: "created";
             updated: "updated";
         }>;
         documentDiff: z.ZodString;
-    }, z.core.$strict>>;
+    }, z.core.$strict>>>;
     cleanup: z.ZodOptional<z.ZodObject<{
         kind: z.ZodLiteral<"lock-release-failed">;
-        diagnostics: z.ZodArray<z.ZodString>;
+        diagnostics: z.ZodReadonly<z.ZodArray<z.ZodString>>;
     }, z.core.$strict>>;
-    aliases: z.ZodArray<z.ZodObject<{
+    aliases: z.ZodReadonly<z.ZodArray<z.ZodObject<{
         alias: z.ZodString;
         taskId: z.ZodPipe<z.ZodString, z.ZodTransform<`task/${string}`, string>>;
-    }, z.core.$strict>>;
-    admissionOrder: z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<`task/${string}`, string>>>;
+    }, z.core.$strict>>>;
+    admissionOrder: z.ZodReadonly<z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<`task/${string}`, string>>>>;
+    admissions: z.ZodReadonly<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"new">;
+        position: z.ZodNumber;
+        alias: z.ZodOptional<z.ZodString>;
+        title: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"existing">;
+        position: z.ZodNumber;
+        taskId: z.ZodPipe<z.ZodString, z.ZodTransform<`task/${string}`, string>>;
+        title: z.ZodString;
+    }, z.core.$strict>], "kind">>>;
     kind: z.ZodLiteral<"accepted">;
 }, z.core.$strict>, z.ZodTransform<WithoutUndefined<{
-    documentChanges: {
+    documentChanges: readonly {
         taskId: `task/${string}`;
         kind: "created" | "updated";
         documentDiff: string;
     }[];
-    aliases: {
+    aliases: readonly {
         alias: string;
         taskId: `task/${string}`;
     }[];
-    admissionOrder: `task/${string}`[];
+    admissionOrder: readonly `task/${string}`[];
+    admissions: readonly ({
+        kind: "new";
+        position: number;
+        title: string;
+        alias?: string | undefined;
+    } | {
+        kind: "existing";
+        position: number;
+        taskId: `task/${string}`;
+        title: string;
+    })[];
     kind: "accepted";
     cleanup?: {
         kind: "lock-release-failed";
-        diagnostics: string[];
+        diagnostics: readonly string[];
     } | undefined;
 }>, {
-    documentChanges: {
+    documentChanges: readonly {
         taskId: `task/${string}`;
         kind: "created" | "updated";
         documentDiff: string;
     }[];
-    aliases: {
+    aliases: readonly {
         alias: string;
         taskId: `task/${string}`;
     }[];
-    admissionOrder: `task/${string}`[];
+    admissionOrder: readonly `task/${string}`[];
+    admissions: readonly ({
+        kind: "new";
+        position: number;
+        title: string;
+        alias?: string | undefined;
+    } | {
+        kind: "existing";
+        position: number;
+        taskId: `task/${string}`;
+        title: string;
+    })[];
     kind: "accepted";
     cleanup?: {
         kind: "lock-release-failed";
-        diagnostics: string[];
+        diagnostics: readonly string[];
     } | undefined;
 }>>, z.ZodObject<{
     kind: z.ZodLiteral<"refused">;
     refusal: z.ZodObject<{
         kind: z.ZodLiteral<"invalid-composition">;
-        diagnostics: z.ZodArray<z.ZodObject<{
+        diagnostics: z.ZodReadonly<z.ZodArray<z.ZodObject<{
             line: z.ZodNumber;
             reason: z.ZodString;
             token: z.ZodString;
-        }, z.core.$strict>>;
+        }, z.core.$strict>>>;
     }, z.core.$strict>;
 }, z.core.$strict>, z.ZodPipe<z.ZodObject<{
-    documentChanges: z.ZodArray<z.ZodObject<{
+    documentChanges: z.ZodReadonly<z.ZodArray<z.ZodObject<{
         taskId: z.ZodPipe<z.ZodString, z.ZodTransform<`task/${string}`, string>>;
         kind: z.ZodEnum<{
             created: "created";
             updated: "updated";
         }>;
         documentDiff: z.ZodString;
-    }, z.core.$strict>>;
+    }, z.core.$strict>>>;
     cleanup: z.ZodOptional<z.ZodObject<{
         kind: z.ZodLiteral<"lock-release-failed">;
-        diagnostics: z.ZodArray<z.ZodString>;
+        diagnostics: z.ZodReadonly<z.ZodArray<z.ZodString>>;
     }, z.core.$strict>>;
     stopped: z.ZodUnion<readonly [z.ZodUnion<readonly [z.ZodObject<{
         kind: z.ZodLiteral<"task-missing">;
@@ -1547,11 +1567,11 @@ export declare const taskMutationExecutionResultSchema: z.ZodUnion<readonly [z.Z
         declaringTask: z.ZodPipe<z.ZodString, z.ZodTransform<`task/${string}`, string>>;
     }, z.core.$strict>, z.ZodObject<{
         kind: z.ZodLiteral<"invalid-composition">;
-        diagnostics: z.ZodArray<z.ZodObject<{
+        diagnostics: z.ZodReadonly<z.ZodArray<z.ZodObject<{
             line: z.ZodNumber;
             reason: z.ZodString;
             token: z.ZodString;
-        }, z.core.$strict>>;
+        }, z.core.$strict>>>;
     }, z.core.$strict>]>, z.ZodObject<{
         kind: z.ZodLiteral<"retry">;
         reason: z.ZodEnum<{
@@ -1560,19 +1580,40 @@ export declare const taskMutationExecutionResultSchema: z.ZodUnion<readonly [z.Z
         }>;
     }, z.core.$strict>]>;
     draft: z.ZodString;
-    aliases: z.ZodArray<z.ZodObject<{
+    aliases: z.ZodReadonly<z.ZodArray<z.ZodObject<{
         alias: z.ZodString;
         taskId: z.ZodPipe<z.ZodString, z.ZodTransform<`task/${string}`, string>>;
-    }, z.core.$strict>>;
-    admissionOrder: z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<`task/${string}`, string>>>;
+    }, z.core.$strict>>>;
+    admissionOrder: z.ZodReadonly<z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<`task/${string}`, string>>>>;
+    admissions: z.ZodReadonly<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"new">;
+        position: z.ZodNumber;
+        alias: z.ZodOptional<z.ZodString>;
+        title: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"existing">;
+        position: z.ZodNumber;
+        taskId: z.ZodPipe<z.ZodString, z.ZodTransform<`task/${string}`, string>>;
+        title: z.ZodString;
+    }, z.core.$strict>], "kind">>>;
     kind: z.ZodLiteral<"incomplete">;
 }, z.core.$strict>, z.ZodTransform<WithoutUndefined<{
-    documentChanges: {
+    documentChanges: readonly {
         taskId: `task/${string}`;
         kind: "created" | "updated";
         documentDiff: string;
     }[];
     stopped: {
+        kind: "retry";
+        reason: "concurrent-modification" | "busy";
+    } | {
+        kind: "invalid-composition";
+        diagnostics: readonly {
+            line: number;
+            reason: string;
+            token: string;
+        }[];
+    } | {
         kind: "task-missing";
         taskId: `task/${string}`;
     } | {
@@ -1591,35 +1632,46 @@ export declare const taskMutationExecutionResultSchema: z.ZodUnion<readonly [z.Z
         taskId: `task/${string}`;
         related: `task/${string}`;
         declaringTask: `task/${string}`;
-    } | {
-        kind: "invalid-composition";
-        diagnostics: {
-            line: number;
-            reason: string;
-            token: string;
-        }[];
-    } | {
-        kind: "retry";
-        reason: "concurrent-modification" | "busy";
     };
     draft: string;
-    aliases: {
+    aliases: readonly {
         alias: string;
         taskId: `task/${string}`;
     }[];
-    admissionOrder: `task/${string}`[];
+    admissionOrder: readonly `task/${string}`[];
+    admissions: readonly ({
+        kind: "new";
+        position: number;
+        title: string;
+        alias?: string | undefined;
+    } | {
+        kind: "existing";
+        position: number;
+        taskId: `task/${string}`;
+        title: string;
+    })[];
     kind: "incomplete";
     cleanup?: {
         kind: "lock-release-failed";
-        diagnostics: string[];
+        diagnostics: readonly string[];
     } | undefined;
 }>, {
-    documentChanges: {
+    documentChanges: readonly {
         taskId: `task/${string}`;
         kind: "created" | "updated";
         documentDiff: string;
     }[];
     stopped: {
+        kind: "retry";
+        reason: "concurrent-modification" | "busy";
+    } | {
+        kind: "invalid-composition";
+        diagnostics: readonly {
+            line: number;
+            reason: string;
+            token: string;
+        }[];
+    } | {
         kind: "task-missing";
         taskId: `task/${string}`;
     } | {
@@ -1638,28 +1690,37 @@ export declare const taskMutationExecutionResultSchema: z.ZodUnion<readonly [z.Z
         taskId: `task/${string}`;
         related: `task/${string}`;
         declaringTask: `task/${string}`;
-    } | {
-        kind: "invalid-composition";
-        diagnostics: {
-            line: number;
-            reason: string;
-            token: string;
-        }[];
-    } | {
-        kind: "retry";
-        reason: "concurrent-modification" | "busy";
     };
     draft: string;
-    aliases: {
+    aliases: readonly {
         alias: string;
         taskId: `task/${string}`;
     }[];
-    admissionOrder: `task/${string}`[];
+    admissionOrder: readonly `task/${string}`[];
+    admissions: readonly ({
+        kind: "new";
+        position: number;
+        title: string;
+        alias?: string | undefined;
+    } | {
+        kind: "existing";
+        position: number;
+        taskId: `task/${string}`;
+        title: string;
+    })[];
     kind: "incomplete";
     cleanup?: {
         kind: "lock-release-failed";
-        diagnostics: string[];
+        diagnostics: readonly string[];
     } | undefined;
 }>>]>]>;
-export declare function isTaskMutationExecutionResult(value: unknown): value is TaskMutationExecutionResult;
-export {};
+export type TaskView = z.infer<typeof taskViewSchema>;
+export type TaskCleanupFailure = z.infer<typeof taskCleanupFailureSchema>;
+export type TaskCompositionDiagnostic = z.infer<typeof compositionDiagnosticSchema>;
+export type TaskRefusal = z.infer<typeof taskRefusalSchema>;
+export type TaskRetry = z.infer<typeof taskRetrySchema>["reason"];
+export type TaskMutationResult = z.infer<typeof taskMutationResultSchema>;
+export type TaskUpdateResult = z.infer<typeof taskUpdateResultSchema>;
+export type TaskBatchResult = z.infer<typeof taskBatchResultSchema>;
+export type TaskCompositionResult = z.infer<typeof taskCompositionResultSchema>;
+export type TaskMutationExecutionResult = z.infer<typeof taskMutationExecutionResultSchema>;