@onetaskgraph/sdk 0.12.13 → 0.13.0

package/dist/generated/schemas.d.ts

@@ -787,10 +787,38 @@ export declare const runtimeSchemas: {
                 readonly required: readonly ["task", "id"];
                 readonly type: "object";
             };
+            readonly GlobalId: {
+                readonly description: "One item, qualified by the source it came from.\n\nRendered `<source>:<native>` and parsed by splitting on the **first** colon,\nso a native id may contain colons freely.";
+                readonly type: "string";
+            };
             readonly NativeId: {
                 readonly description: "A source's own opaque identifier for one item.\n\nDeliberately unvalidated: a native id is whatever the upstream system says it\nis, colons included. The engine parses a qualified id by splitting on the\n*first* colon precisely so this stays true.";
                 readonly type: "string";
             };
+            readonly Priority: {
+                readonly description: "How much a task matters, in the one vocabulary every source is normalised into.\n\nFive values, most pressing first after [`None`](Self::None): Linear's own priority has\nexactly these, and a source whose backend has none of its own maps its representation\nonto them. `none` is a value rather than an absent field, because \"no priority is set\" is\nsomething a person sets — writing `none` clears a priority — and a reader tells it apart\nfrom nothing by the value alone.";
+                readonly oneOf: readonly [{
+                    readonly const: "none";
+                    readonly description: "No priority is set.";
+                    readonly type: "string";
+                }, {
+                    readonly const: "urgent";
+                    readonly description: "Drop everything for it.";
+                    readonly type: "string";
+                }, {
+                    readonly const: "high";
+                    readonly description: "Next, before the rest.";
+                    readonly type: "string";
+                }, {
+                    readonly const: "medium";
+                    readonly description: "In its turn.";
+                    readonly type: "string";
+                }, {
+                    readonly const: "low";
+                    readonly description: "When there is nothing more pressing.";
+                    readonly type: "string";
+                }];
+            };
             readonly Spent: {
                 readonly description: "What one command spent, summed over the sources in it that meter their own requests.\n\n**Source-owned.** Every figure is what a source said it sent and spent while the command\nran, read through [`TaskSource::metering`](onetaskgraph_plugin_api::TaskSource::metering)\nbefore the command and again after it. The engine adds the differences up by name and\ninterprets none of them, which is why the budget and unit names are open vocabulary.";
                 readonly properties: {
@@ -811,6 +839,57 @@ export declare const runtimeSchemas: {
                 readonly required: readonly ["requests", "budgets"];
                 readonly type: "object";
             };
+            readonly Status: {
+                readonly description: "A source's status, kept in both normalised and original form.\n\n`category` is what every filter compares against; `name` is the source's own\nwording, preserved so display never flattens \"In Review\" into \"In Progress\".";
+                readonly properties: {
+                    readonly category: {
+                        readonly $ref: "#/$defs/StatusCategory";
+                        readonly description: "The normalised value filters compare against.";
+                    };
+                    readonly name: {
+                        readonly description: "The source's own label for this status.";
+                        readonly type: "string";
+                    };
+                };
+                readonly required: readonly ["category", "name"];
+                readonly type: "object";
+            };
+            readonly StatusCategory: {
+                readonly description: "The normalised status vocabulary shared across every source.";
+                readonly oneOf: readonly [{
+                    readonly const: "draft";
+                    readonly description: "Written down but not yet committed to as work.";
+                    readonly type: "string";
+                }, {
+                    readonly const: "backlog";
+                    readonly description: "Known about, not yet accepted as ready to work.";
+                    readonly type: "string";
+                }, {
+                    readonly const: "todo";
+                    readonly description: "Accepted and ready to be picked up, and nothing has claimed it.";
+                    readonly type: "string";
+                }, {
+                    readonly const: "queued";
+                    readonly description: "Claimed by work that will do it, and not yet started.";
+                    readonly type: "string";
+                }, {
+                    readonly const: "in-progress";
+                    readonly description: "Being worked on.";
+                    readonly type: "string";
+                }, {
+                    readonly const: "done";
+                    readonly description: "Finished.";
+                    readonly type: "string";
+                }, {
+                    readonly const: "cancelled";
+                    readonly description: "Abandoned.";
+                    readonly type: "string";
+                }, {
+                    readonly const: "unknown";
+                    readonly description: "The source reported a status this vocabulary cannot place.";
+                    readonly type: "string";
+                }];
+            };
             readonly WriteFallback: {
                 readonly description: "That an expected write read its target before writing, and why.";
                 readonly properties: {
@@ -887,21 +966,38 @@ export declare const runtimeSchemas: {
                 readonly type: "object";
             };
             readonly WriteResult: {
-                readonly description: "What each mutation of an expected write came to, built from the mutations' own responses.";
+                readonly description: "What an item holds once a write is done, read off the write's own responses — and, for an\nexpected write, what each mutation it sent came to.\n\nEvery write verb and every item a copy lands answers one, with no request added for it: a\nfield the write kept is what the read before it held. `version` is `null` where the source\ncannot vouch for a token from its write's responses — a GitHub board for an item it has just\nwritten, a stdio-hosted plugin, an in-memory source — and otherwise the token a read would\nthen give.";
                 readonly properties: {
                     readonly parts: {
-                        readonly description: "One per mutation sent, in the order sent.";
+                        readonly description: "One per mutation an expected write sent, in the order sent — absent for a write made\nwithout `--expect`.";
                         readonly items: {
                             readonly $ref: "#/$defs/WritePart";
                         };
-                        readonly type: "array";
+                        readonly type: readonly ["array", "null"];
+                    };
+                    readonly priority: {
+                        readonly anyOf: readonly [{
+                            readonly $ref: "#/$defs/Priority";
+                        }, {
+                            readonly type: "null";
+                        }];
+                        readonly default: null;
+                        readonly description: "A task's priority after the write — `null` for a project or a document, which carry\nnone, and where an expected write that failed cannot say.";
+                    };
+                    readonly status: {
+                        readonly anyOf: readonly [{
+                            readonly $ref: "#/$defs/Status";
+                        }, {
+                            readonly type: "null";
+                        }];
+                        readonly default: null;
+                        readonly description: "The item's status after the write, exactly as `task show` spells it — `null` for a\ndocument, which has none, and where an expected write that failed cannot say.";
                     };
                     readonly version: {
-                        readonly description: "The task's version after the write, where the last response determines it.";
+                        readonly description: "The item's version after the write, where the write's responses determine it.";
                         readonly type: readonly ["string", "null"];
                     };
                 };
-                readonly required: readonly ["parts"];
                 readonly type: "object";
             };
         };
@@ -933,6 +1029,14 @@ export declare const runtimeSchemas: {
                 readonly $ref: "#/$defs/NativeId";
                 readonly description: "The comment's own id, exactly as its source issued it.\n\nOpaque, as every [`NativeId`] is, and never qualified: a comment is addressed through\nthe qualified id of the task it is on, so its own id needs no source of its own.";
             };
+            readonly item: {
+                readonly anyOf: readonly [{
+                    readonly $ref: "#/$defs/GlobalId";
+                }, {
+                    readonly type: "null";
+                }];
+                readonly description: "The qualified id of the task the comment was added to — present on `task comment add`'s\nanswer, so a caller records what it commented on from the answer alone.";
+            };
             readonly origin: {
                 readonly anyOf: readonly [{
                     readonly $ref: "#/$defs/CommentOrigin";
@@ -1576,6 +1680,10 @@ export declare const runtimeSchemas: {
                     readonly const: "match";
                     readonly description: "A search of the destination by the caller's `--match-by`.";
                     readonly type: "string";
+                }, {
+                    readonly const: "intent";
+                    readonly description: "The item the destination holds under the key of a create an earlier attempt of this\ncopy recorded its intent for, at `onetaskgraph.creating`: that attempt's create,\nfinished rather than made twice.";
+                    readonly type: "string";
                 }];
             };
             readonly Failure: {
@@ -1922,6 +2030,10 @@ export declare const runtimeSchemas: {
                     readonly const: "match";
                     readonly description: "A search of the destination by the caller's `--match-by`.";
                     readonly type: "string";
+                }, {
+                    readonly const: "intent";
+                    readonly description: "The item the destination holds under the key of a create an earlier attempt of this\ncopy recorded its intent for, at `onetaskgraph.creating`: that attempt's create,\nfinished rather than made twice.";
+                    readonly type: "string";
                 }];
             };
             readonly Failure: {
@@ -1998,6 +2110,45 @@ export declare const runtimeSchemas: {
                 readonly required: readonly ["destination"];
                 readonly type: "object";
             };
+            readonly Priority: {
+                readonly description: "How much a task matters, in the one vocabulary every source is normalised into.\n\nFive values, most pressing first after [`None`](Self::None): Linear's own priority has\nexactly these, and a source whose backend has none of its own maps its representation\nonto them. `none` is a value rather than an absent field, because \"no priority is set\" is\nsomething a person sets — writing `none` clears a priority — and a reader tells it apart\nfrom nothing by the value alone.";
+                readonly oneOf: readonly [{
+                    readonly const: "none";
+                    readonly description: "No priority is set.";
+                    readonly type: "string";
+                }, {
+                    readonly const: "urgent";
+                    readonly description: "Drop everything for it.";
+                    readonly type: "string";
+                }, {
+                    readonly const: "high";
+                    readonly description: "Next, before the rest.";
+                    readonly type: "string";
+                }, {
+                    readonly const: "medium";
+                    readonly description: "In its turn.";
+                    readonly type: "string";
+                }, {
+                    readonly const: "low";
+                    readonly description: "When there is nothing more pressing.";
+                    readonly type: "string";
+                }];
+            };
+            readonly PriorityCondition: {
+                readonly description: "What a guarded copy found a counterpart's priority at, and whether that met the condition.";
+                readonly properties: {
+                    readonly held: {
+                        readonly $ref: "#/$defs/Priority";
+                        readonly description: "The counterpart's priority, as the copy's own pre-write read held it.";
+                    };
+                    readonly met: {
+                        readonly description: "Whether that priority is one the condition names.";
+                        readonly type: "boolean";
+                    };
+                };
+                readonly required: readonly ["held", "met"];
+                readonly type: "object";
+            };
             readonly SourceName: {
                 readonly description: "The name a configuration document gives one configured source.";
                 readonly pattern: "^[a-z0-9][a-z0-9-]*$";
@@ -2023,6 +2174,72 @@ export declare const runtimeSchemas: {
                 readonly required: readonly ["requests", "budgets"];
                 readonly type: "object";
             };
+            readonly Status: {
+                readonly description: "A source's status, kept in both normalised and original form.\n\n`category` is what every filter compares against; `name` is the source's own\nwording, preserved so display never flattens \"In Review\" into \"In Progress\".";
+                readonly properties: {
+                    readonly category: {
+                        readonly $ref: "#/$defs/StatusCategory";
+                        readonly description: "The normalised value filters compare against.";
+                    };
+                    readonly name: {
+                        readonly description: "The source's own label for this status.";
+                        readonly type: "string";
+                    };
+                };
+                readonly required: readonly ["category", "name"];
+                readonly type: "object";
+            };
+            readonly StatusCategory: {
+                readonly description: "The normalised status vocabulary shared across every source.";
+                readonly oneOf: readonly [{
+                    readonly const: "draft";
+                    readonly description: "Written down but not yet committed to as work.";
+                    readonly type: "string";
+                }, {
+                    readonly const: "backlog";
+                    readonly description: "Known about, not yet accepted as ready to work.";
+                    readonly type: "string";
+                }, {
+                    readonly const: "todo";
+                    readonly description: "Accepted and ready to be picked up, and nothing has claimed it.";
+                    readonly type: "string";
+                }, {
+                    readonly const: "queued";
+                    readonly description: "Claimed by work that will do it, and not yet started.";
+                    readonly type: "string";
+                }, {
+                    readonly const: "in-progress";
+                    readonly description: "Being worked on.";
+                    readonly type: "string";
+                }, {
+                    readonly const: "done";
+                    readonly description: "Finished.";
+                    readonly type: "string";
+                }, {
+                    readonly const: "cancelled";
+                    readonly description: "Abandoned.";
+                    readonly type: "string";
+                }, {
+                    readonly const: "unknown";
+                    readonly description: "The source reported a status this vocabulary cannot place.";
+                    readonly type: "string";
+                }];
+            };
+            readonly StatusCondition: {
+                readonly description: "What a guarded copy found a counterpart's status at, and whether that met the condition.";
+                readonly properties: {
+                    readonly held: {
+                        readonly $ref: "#/$defs/StatusCategory";
+                        readonly description: "The counterpart's status category, as the copy's own pre-write read held it.";
+                    };
+                    readonly met: {
+                        readonly description: "Whether that category is one the condition names.";
+                        readonly type: "boolean";
+                    };
+                };
+                readonly required: readonly ["held", "met"];
+                readonly type: "object";
+            };
             readonly WriteFallback: {
                 readonly description: "That an expected write read its target before writing, and why.";
                 readonly properties: {
@@ -2099,21 +2316,38 @@ export declare const runtimeSchemas: {
                 readonly type: "object";
             };
             readonly WriteResult: {
-                readonly description: "What each mutation of an expected write came to, built from the mutations' own responses.";
+                readonly description: "What an item holds once a write is done, read off the write's own responses — and, for an\nexpected write, what each mutation it sent came to.\n\nEvery write verb and every item a copy lands answers one, with no request added for it: a\nfield the write kept is what the read before it held. `version` is `null` where the source\ncannot vouch for a token from its write's responses — a GitHub board for an item it has just\nwritten, a stdio-hosted plugin, an in-memory source — and otherwise the token a read would\nthen give.";
                 readonly properties: {
                     readonly parts: {
-                        readonly description: "One per mutation sent, in the order sent.";
+                        readonly description: "One per mutation an expected write sent, in the order sent — absent for a write made\nwithout `--expect`.";
                         readonly items: {
                             readonly $ref: "#/$defs/WritePart";
                         };
-                        readonly type: "array";
+                        readonly type: readonly ["array", "null"];
+                    };
+                    readonly priority: {
+                        readonly anyOf: readonly [{
+                            readonly $ref: "#/$defs/Priority";
+                        }, {
+                            readonly type: "null";
+                        }];
+                        readonly default: null;
+                        readonly description: "A task's priority after the write — `null` for a project or a document, which carry\nnone, and where an expected write that failed cannot say.";
+                    };
+                    readonly status: {
+                        readonly anyOf: readonly [{
+                            readonly $ref: "#/$defs/Status";
+                        }, {
+                            readonly type: "null";
+                        }];
+                        readonly default: null;
+                        readonly description: "The item's status after the write, exactly as `task show` spells it — `null` for a\ndocument, which has none, and where an expected write that failed cannot say.";
                     };
                     readonly version: {
-                        readonly description: "The task's version after the write, where the last response determines it.";
+                        readonly description: "The item's version after the write, where the write's responses determine it.";
                         readonly type: readonly ["string", "null"];
                     };
                 };
-                readonly required: readonly ["parts"];
                 readonly type: "object";
             };
         };
@@ -2283,6 +2517,14 @@ export declare const runtimeSchemas: {
                 }];
                 readonly description: "That the write had to read its target first, and why — absent when it sent only its\nmutations.";
             };
+            readonly held: {
+                readonly anyOf: readonly [{
+                    readonly $ref: "#/$defs/WriteResult";
+                }, {
+                    readonly type: "null";
+                }];
+                readonly description: "What the counterpart held, as the copy's read of it before writing found it — present\nonly on an item the copy refused after that read, such as `destination-status`.";
+            };
             readonly placed: {
                 readonly anyOf: readonly [{
                     readonly $ref: "#/$defs/Placement";
@@ -2291,13 +2533,21 @@ export declare const runtimeSchemas: {
                 }];
                 readonly description: "Which source a routed copy placed it in, and the index of the route entry that\nmatched — `null` there when none did.\n\nPresent for every item a copy into a source declaring `routes` landed, a dry run's\nincluded, so a would-be create still says where it would go; absent for a copy into\na source with none, whose output is what it always was, and for an orphan, which was\nnot placed at all.";
             };
+            readonly priority_condition: {
+                readonly anyOf: readonly [{
+                    readonly $ref: "#/$defs/PriorityCondition";
+                }, {
+                    readonly type: "null";
+                }];
+                readonly description: "What `--when-destination-priority` found the counterpart's priority at, and whether\nthat met it — present only when the copy was given the condition and this item was an\nupdate of a task.";
+            };
             readonly result: {
                 readonly anyOf: readonly [{
                     readonly $ref: "#/$defs/WriteResult";
                 }, {
                     readonly type: "null";
                 }];
-                readonly description: "What each mutation the write sent came to, and the version it left the task at — for a\nsource that reports its writes' parts.";
+                readonly description: "What the item holds once the write is done — its version, status and priority — and,\nfor a write made with `--expect` on a source that reports its writes' parts, what each\nmutation it sent came to. Absent for a dry run and for an item nothing was written to\nor read of.";
             };
             readonly source: {
                 readonly $ref: "#/$defs/GlobalId";
@@ -2311,6 +2561,14 @@ export declare const runtimeSchemas: {
                 }];
                 readonly description: "What the write spent at the sources that meter their own requests — the fallback's\nread included.";
             };
+            readonly status_condition: {
+                readonly anyOf: readonly [{
+                    readonly $ref: "#/$defs/StatusCondition";
+                }, {
+                    readonly type: "null";
+                }];
+                readonly description: "What `--when-destination-status` found the counterpart's status at, and whether that\nmet it — present only when the copy was given the condition and this item was an update\nof a task, a refused one included.";
+            };
         };
         readonly required: readonly ["source"];
         readonly title: "CopyOutcome";
@@ -2560,6 +2818,14 @@ export declare const runtimeSchemas: {
                         }];
                         readonly description: "That the write had to read its target first, and why — absent when it sent only its\nmutations.";
                     };
+                    readonly held: {
+                        readonly anyOf: readonly [{
+                            readonly $ref: "#/$defs/WriteResult";
+                        }, {
+                            readonly type: "null";
+                        }];
+                        readonly description: "What the counterpart held, as the copy's read of it before writing found it — present\nonly on an item the copy refused after that read, such as `destination-status`.";
+                    };
                     readonly placed: {
                         readonly anyOf: readonly [{
                             readonly $ref: "#/$defs/Placement";
@@ -2568,13 +2834,21 @@ export declare const runtimeSchemas: {
                         }];
                         readonly description: "Which source a routed copy placed it in, and the index of the route entry that\nmatched — `null` there when none did.\n\nPresent for every item a copy into a source declaring `routes` landed, a dry run's\nincluded, so a would-be create still says where it would go; absent for a copy into\na source with none, whose output is what it always was, and for an orphan, which was\nnot placed at all.";
                     };
+                    readonly priority_condition: {
+                        readonly anyOf: readonly [{
+                            readonly $ref: "#/$defs/PriorityCondition";
+                        }, {
+                            readonly type: "null";
+                        }];
+                        readonly description: "What `--when-destination-priority` found the counterpart's priority at, and whether\nthat met it — present only when the copy was given the condition and this item was an\nupdate of a task.";
+                    };
                     readonly result: {
                         readonly anyOf: readonly [{
                             readonly $ref: "#/$defs/WriteResult";
                         }, {
                             readonly type: "null";
                         }];
-                        readonly description: "What each mutation the write sent came to, and the version it left the task at — for a\nsource that reports its writes' parts.";
+                        readonly description: "What the item holds once the write is done — its version, status and priority — and,\nfor a write made with `--expect` on a source that reports its writes' parts, what each\nmutation it sent came to. Absent for a dry run and for an item nothing was written to\nor read of.";
                     };
                     readonly source: {
                         readonly $ref: "#/$defs/GlobalId";
@@ -2588,6 +2862,14 @@ export declare const runtimeSchemas: {
                         }];
                         readonly description: "What the write spent at the sources that meter their own requests — the fallback's\nread included.";
                     };
+                    readonly status_condition: {
+                        readonly anyOf: readonly [{
+                            readonly $ref: "#/$defs/StatusCondition";
+                        }, {
+                            readonly type: "null";
+                        }];
+                        readonly description: "What `--when-destination-status` found the counterpart's status at, and whether that\nmet it — present only when the copy was given the condition and this item was an update\nof a task, a refused one included.";
+                    };
                 };
                 readonly required: readonly ["source"];
                 readonly type: "object";
@@ -2614,6 +2896,10 @@ export declare const runtimeSchemas: {
                     readonly const: "match";
                     readonly description: "A search of the destination by the caller's `--match-by`.";
                     readonly type: "string";
+                }, {
+                    readonly const: "intent";
+                    readonly description: "The item the destination holds under the key of a create an earlier attempt of this\ncopy recorded its intent for, at `onetaskgraph.creating`: that attempt's create,\nfinished rather than made twice.";
+                    readonly type: "string";
                 }];
             };
             readonly Delivered: {
@@ -2782,6 +3068,45 @@ export declare const runtimeSchemas: {
                 readonly required: readonly ["destination"];
                 readonly type: "object";
             };
+            readonly Priority: {
+                readonly description: "How much a task matters, in the one vocabulary every source is normalised into.\n\nFive values, most pressing first after [`None`](Self::None): Linear's own priority has\nexactly these, and a source whose backend has none of its own maps its representation\nonto them. `none` is a value rather than an absent field, because \"no priority is set\" is\nsomething a person sets — writing `none` clears a priority — and a reader tells it apart\nfrom nothing by the value alone.";
+                readonly oneOf: readonly [{
+                    readonly const: "none";
+                    readonly description: "No priority is set.";
+                    readonly type: "string";
+                }, {
+                    readonly const: "urgent";
+                    readonly description: "Drop everything for it.";
+                    readonly type: "string";
+                }, {
+                    readonly const: "high";
+                    readonly description: "Next, before the rest.";
+                    readonly type: "string";
+                }, {
+                    readonly const: "medium";
+                    readonly description: "In its turn.";
+                    readonly type: "string";
+                }, {
+                    readonly const: "low";
+                    readonly description: "When there is nothing more pressing.";
+                    readonly type: "string";
+                }];
+            };
+            readonly PriorityCondition: {
+                readonly description: "What a guarded copy found a counterpart's priority at, and whether that met the condition.";
+                readonly properties: {
+                    readonly held: {
+                        readonly $ref: "#/$defs/Priority";
+                        readonly description: "The counterpart's priority, as the copy's own pre-write read held it.";
+                    };
+                    readonly met: {
+                        readonly description: "Whether that priority is one the condition names.";
+                        readonly type: "boolean";
+                    };
+                };
+                readonly required: readonly ["held", "met"];
+                readonly type: "object";
+            };
             readonly SourceName: {
                 readonly description: "The name a configuration document gives one configured source.";
                 readonly pattern: "^[a-z0-9][a-z0-9-]*$";
@@ -2807,6 +3132,21 @@ export declare const runtimeSchemas: {
                 readonly required: readonly ["requests", "budgets"];
                 readonly type: "object";
             };
+            readonly Status: {
+                readonly description: "A source's status, kept in both normalised and original form.\n\n`category` is what every filter compares against; `name` is the source's own\nwording, preserved so display never flattens \"In Review\" into \"In Progress\".";
+                readonly properties: {
+                    readonly category: {
+                        readonly $ref: "#/$defs/StatusCategory";
+                        readonly description: "The normalised value filters compare against.";
+                    };
+                    readonly name: {
+                        readonly description: "The source's own label for this status.";
+                        readonly type: "string";
+                    };
+                };
+                readonly required: readonly ["category", "name"];
+                readonly type: "object";
+            };
             readonly StatusCategory: {
                 readonly description: "The normalised status vocabulary shared across every source.";
                 readonly oneOf: readonly [{
@@ -2843,6 +3183,21 @@ export declare const runtimeSchemas: {
                     readonly type: "string";
                 }];
             };
+            readonly StatusCondition: {
+                readonly description: "What a guarded copy found a counterpart's status at, and whether that met the condition.";
+                readonly properties: {
+                    readonly held: {
+                        readonly $ref: "#/$defs/StatusCategory";
+                        readonly description: "The counterpart's status category, as the copy's own pre-write read held it.";
+                    };
+                    readonly met: {
+                        readonly description: "Whether that category is one the condition names.";
+                        readonly type: "boolean";
+                    };
+                };
+                readonly required: readonly ["held", "met"];
+                readonly type: "object";
+            };
             readonly WriteFallback: {
                 readonly description: "That an expected write read its target before writing, and why.";
                 readonly properties: {
@@ -2919,21 +3274,38 @@ export declare const runtimeSchemas: {
                 readonly type: "object";
             };
             readonly WriteResult: {
-                readonly description: "What each mutation of an expected write came to, built from the mutations' own responses.";
+                readonly description: "What an item holds once a write is done, read off the write's own responses — and, for an\nexpected write, what each mutation it sent came to.\n\nEvery write verb and every item a copy lands answers one, with no request added for it: a\nfield the write kept is what the read before it held. `version` is `null` where the source\ncannot vouch for a token from its write's responses — a GitHub board for an item it has just\nwritten, a stdio-hosted plugin, an in-memory source — and otherwise the token a read would\nthen give.";
                 readonly properties: {
                     readonly parts: {
-                        readonly description: "One per mutation sent, in the order sent.";
+                        readonly description: "One per mutation an expected write sent, in the order sent — absent for a write made\nwithout `--expect`.";
                         readonly items: {
                             readonly $ref: "#/$defs/WritePart";
                         };
-                        readonly type: "array";
+                        readonly type: readonly ["array", "null"];
+                    };
+                    readonly priority: {
+                        readonly anyOf: readonly [{
+                            readonly $ref: "#/$defs/Priority";
+                        }, {
+                            readonly type: "null";
+                        }];
+                        readonly default: null;
+                        readonly description: "A task's priority after the write — `null` for a project or a document, which carry\nnone, and where an expected write that failed cannot say.";
+                    };
+                    readonly status: {
+                        readonly anyOf: readonly [{
+                            readonly $ref: "#/$defs/Status";
+                        }, {
+                            readonly type: "null";
+                        }];
+                        readonly default: null;
+                        readonly description: "The item's status after the write, exactly as `task show` spells it — `null` for a\ndocument, which has none, and where an expected write that failed cannot say.";
                     };
                     readonly version: {
-                        readonly description: "The task's version after the write, where the last response determines it.";
+                        readonly description: "The item's version after the write, where the write's responses determine it.";
                         readonly type: readonly ["string", "null"];
                     };
                 };
-                readonly required: readonly ["parts"];
                 readonly type: "object";
             };
         };
@@ -3019,9 +3391,33 @@ export declare const runtimeSchemas: {
             readonly const: "match";
             readonly description: "A search of the destination by the caller's `--match-by`.";
             readonly type: "string";
+        }, {
+            readonly const: "intent";
+            readonly description: "The item the destination holds under the key of a create an earlier attempt of this\ncopy recorded its intent for, at `onetaskgraph.creating`: that attempt's create,\nfinished rather than made twice.";
+            readonly type: "string";
         }];
         readonly title: "CopyVia";
     };
+    readonly CreateSettings: {
+        readonly $schema: "https://json-schema.org/draft/2020-12/schema";
+        readonly description: "How a copy out of one source keeps a create safe to retry: its two settings, each in whole\nseconds, read off the source's own block beside `cache` and `routes`.\n\n`create_lease_seconds` is how long the intent a copy records on the item it copies, at\n`onetaskgraph.creating`, stays its own before another attempt may take it over — read off\nthe copy's **source**. `create_quiescence_seconds` is how long after an intent was first\ntaken a retry waits for an earlier attempt's create to become listed before creating again\n— read off the copy's **destination**, and only where that destination's lookup by create\nkey can lag a create. Both default to 120 and are left out of a configuration that does not\nset them.";
+        readonly properties: {
+            readonly create_lease_seconds: {
+                readonly description: "Seconds an intent to create stays the holder's own; 120 when absent.";
+                readonly format: "uint64";
+                readonly minimum: 0;
+                readonly type: readonly ["integer", "null"];
+            };
+            readonly create_quiescence_seconds: {
+                readonly description: "Seconds after an intent was first taken that a retry waits for the earlier create to be\nlisted; 120 when absent.";
+                readonly format: "uint64";
+                readonly minimum: 0;
+                readonly type: readonly ["integer", "null"];
+            };
+        };
+        readonly title: "CreateSettings";
+        readonly type: "object";
+    };
     readonly CredentialLayer: {
         readonly $schema: "https://json-schema.org/draft/2020-12/schema";
         readonly description: "Which layer answered for one credential name.";
@@ -3067,6 +3463,30 @@ export declare const runtimeSchemas: {
                 readonly description: "A source's own opaque identifier for one item.\n\nDeliberately unvalidated: a native id is whatever the upstream system says it\nis, colons included. The engine parses a qualified id by splitting on the\n*first* colon precisely so this stays true.";
                 readonly type: "string";
             };
+            readonly Priority: {
+                readonly description: "How much a task matters, in the one vocabulary every source is normalised into.\n\nFive values, most pressing first after [`None`](Self::None): Linear's own priority has\nexactly these, and a source whose backend has none of its own maps its representation\nonto them. `none` is a value rather than an absent field, because \"no priority is set\" is\nsomething a person sets — writing `none` clears a priority — and a reader tells it apart\nfrom nothing by the value alone.";
+                readonly oneOf: readonly [{
+                    readonly const: "none";
+                    readonly description: "No priority is set.";
+                    readonly type: "string";
+                }, {
+                    readonly const: "urgent";
+                    readonly description: "Drop everything for it.";
+                    readonly type: "string";
+                }, {
+                    readonly const: "high";
+                    readonly description: "Next, before the rest.";
+                    readonly type: "string";
+                }, {
+                    readonly const: "medium";
+                    readonly description: "In its turn.";
+                    readonly type: "string";
+                }, {
+                    readonly const: "low";
+                    readonly description: "When there is nothing more pressing.";
+                    readonly type: "string";
+                }];
+            };
             readonly Spent: {
                 readonly description: "What one command spent, summed over the sources in it that meter their own requests.\n\n**Source-owned.** Every figure is what a source said it sent and spent while the command\nran, read through [`TaskSource::metering`](onetaskgraph_plugin_api::TaskSource::metering)\nbefore the command and again after it. The engine adds the differences up by name and\ninterprets none of them, which is why the budget and unit names are open vocabulary.";
                 readonly properties: {
@@ -3087,6 +3507,57 @@ export declare const runtimeSchemas: {
                 readonly required: readonly ["requests", "budgets"];
                 readonly type: "object";
             };
+            readonly Status: {
+                readonly description: "A source's status, kept in both normalised and original form.\n\n`category` is what every filter compares against; `name` is the source's own\nwording, preserved so display never flattens \"In Review\" into \"In Progress\".";
+                readonly properties: {
+                    readonly category: {
+                        readonly $ref: "#/$defs/StatusCategory";
+                        readonly description: "The normalised value filters compare against.";
+                    };
+                    readonly name: {
+                        readonly description: "The source's own label for this status.";
+                        readonly type: "string";
+                    };
+                };
+                readonly required: readonly ["category", "name"];
+                readonly type: "object";
+            };
+            readonly StatusCategory: {
+                readonly description: "The normalised status vocabulary shared across every source.";
+                readonly oneOf: readonly [{
+                    readonly const: "draft";
+                    readonly description: "Written down but not yet committed to as work.";
+                    readonly type: "string";
+                }, {
+                    readonly const: "backlog";
+                    readonly description: "Known about, not yet accepted as ready to work.";
+                    readonly type: "string";
+                }, {
+                    readonly const: "todo";
+                    readonly description: "Accepted and ready to be picked up, and nothing has claimed it.";
+                    readonly type: "string";
+                }, {
+                    readonly const: "queued";
+                    readonly description: "Claimed by work that will do it, and not yet started.";
+                    readonly type: "string";
+                }, {
+                    readonly const: "in-progress";
+                    readonly description: "Being worked on.";
+                    readonly type: "string";
+                }, {
+                    readonly const: "done";
+                    readonly description: "Finished.";
+                    readonly type: "string";
+                }, {
+                    readonly const: "cancelled";
+                    readonly description: "Abandoned.";
+                    readonly type: "string";
+                }, {
+                    readonly const: "unknown";
+                    readonly description: "The source reported a status this vocabulary cannot place.";
+                    readonly type: "string";
+                }];
+            };
             readonly WriteFallback: {
                 readonly description: "That an expected write read its target before writing, and why.";
                 readonly properties: {
@@ -3163,21 +3634,38 @@ export declare const runtimeSchemas: {
                 readonly type: "object";
             };
             readonly WriteResult: {
-                readonly description: "What each mutation of an expected write came to, built from the mutations' own responses.";
+                readonly description: "What an item holds once a write is done, read off the write's own responses — and, for an\nexpected write, what each mutation it sent came to.\n\nEvery write verb and every item a copy lands answers one, with no request added for it: a\nfield the write kept is what the read before it held. `version` is `null` where the source\ncannot vouch for a token from its write's responses — a GitHub board for an item it has just\nwritten, a stdio-hosted plugin, an in-memory source — and otherwise the token a read would\nthen give.";
                 readonly properties: {
                     readonly parts: {
-                        readonly description: "One per mutation sent, in the order sent.";
+                        readonly description: "One per mutation an expected write sent, in the order sent — absent for a write made\nwithout `--expect`.";
                         readonly items: {
                             readonly $ref: "#/$defs/WritePart";
                         };
-                        readonly type: "array";
+                        readonly type: readonly ["array", "null"];
+                    };
+                    readonly priority: {
+                        readonly anyOf: readonly [{
+                            readonly $ref: "#/$defs/Priority";
+                        }, {
+                            readonly type: "null";
+                        }];
+                        readonly default: null;
+                        readonly description: "A task's priority after the write — `null` for a project or a document, which carry\nnone, and where an expected write that failed cannot say.";
+                    };
+                    readonly status: {
+                        readonly anyOf: readonly [{
+                            readonly $ref: "#/$defs/Status";
+                        }, {
+                            readonly type: "null";
+                        }];
+                        readonly default: null;
+                        readonly description: "The item's status after the write, exactly as `task show` spells it — `null` for a\ndocument, which has none, and where an expected write that failed cannot say.";
                     };
                     readonly version: {
-                        readonly description: "The task's version after the write, where the last response determines it.";
+                        readonly description: "The item's version after the write, where the write's responses determine it.";
                         readonly type: readonly ["string", "null"];
                     };
                 };
-                readonly required: readonly ["parts"];
                 readonly type: "object";
             };
         };
@@ -4700,6 +5188,30 @@ export declare const runtimeSchemas: {
                 readonly required: readonly ["budget", "unit", "amount", "lower_bound"];
                 readonly type: "object";
             };
+            readonly Priority: {
+                readonly description: "How much a task matters, in the one vocabulary every source is normalised into.\n\nFive values, most pressing first after [`None`](Self::None): Linear's own priority has\nexactly these, and a source whose backend has none of its own maps its representation\nonto them. `none` is a value rather than an absent field, because \"no priority is set\" is\nsomething a person sets — writing `none` clears a priority — and a reader tells it apart\nfrom nothing by the value alone.";
+                readonly oneOf: readonly [{
+                    readonly const: "none";
+                    readonly description: "No priority is set.";
+                    readonly type: "string";
+                }, {
+                    readonly const: "urgent";
+                    readonly description: "Drop everything for it.";
+                    readonly type: "string";
+                }, {
+                    readonly const: "high";
+                    readonly description: "Next, before the rest.";
+                    readonly type: "string";
+                }, {
+                    readonly const: "medium";
+                    readonly description: "In its turn.";
+                    readonly type: "string";
+                }, {
+                    readonly const: "low";
+                    readonly description: "When there is nothing more pressing.";
+                    readonly type: "string";
+                }];
+            };
             readonly Spent: {
                 readonly description: "What one command spent, summed over the sources in it that meter their own requests.\n\n**Source-owned.** Every figure is what a source said it sent and spent while the command\nran, read through [`TaskSource::metering`](onetaskgraph_plugin_api::TaskSource::metering)\nbefore the command and again after it. The engine adds the differences up by name and\ninterprets none of them, which is why the budget and unit names are open vocabulary.";
                 readonly properties: {
@@ -4720,6 +5232,57 @@ export declare const runtimeSchemas: {
                 readonly required: readonly ["requests", "budgets"];
                 readonly type: "object";
             };
+            readonly Status: {
+                readonly description: "A source's status, kept in both normalised and original form.\n\n`category` is what every filter compares against; `name` is the source's own\nwording, preserved so display never flattens \"In Review\" into \"In Progress\".";
+                readonly properties: {
+                    readonly category: {
+                        readonly $ref: "#/$defs/StatusCategory";
+                        readonly description: "The normalised value filters compare against.";
+                    };
+                    readonly name: {
+                        readonly description: "The source's own label for this status.";
+                        readonly type: "string";
+                    };
+                };
+                readonly required: readonly ["category", "name"];
+                readonly type: "object";
+            };
+            readonly StatusCategory: {
+                readonly description: "The normalised status vocabulary shared across every source.";
+                readonly oneOf: readonly [{
+                    readonly const: "draft";
+                    readonly description: "Written down but not yet committed to as work.";
+                    readonly type: "string";
+                }, {
+                    readonly const: "backlog";
+                    readonly description: "Known about, not yet accepted as ready to work.";
+                    readonly type: "string";
+                }, {
+                    readonly const: "todo";
+                    readonly description: "Accepted and ready to be picked up, and nothing has claimed it.";
+                    readonly type: "string";
+                }, {
+                    readonly const: "queued";
+                    readonly description: "Claimed by work that will do it, and not yet started.";
+                    readonly type: "string";
+                }, {
+                    readonly const: "in-progress";
+                    readonly description: "Being worked on.";
+                    readonly type: "string";
+                }, {
+                    readonly const: "done";
+                    readonly description: "Finished.";
+                    readonly type: "string";
+                }, {
+                    readonly const: "cancelled";
+                    readonly description: "Abandoned.";
+                    readonly type: "string";
+                }, {
+                    readonly const: "unknown";
+                    readonly description: "The source reported a status this vocabulary cannot place.";
+                    readonly type: "string";
+                }];
+            };
             readonly WriteFallback: {
                 readonly description: "That an expected write read its target before writing, and why.";
                 readonly properties: {
@@ -4796,21 +5359,38 @@ export declare const runtimeSchemas: {
                 readonly type: "object";
             };
             readonly WriteResult: {
-                readonly description: "What each mutation of an expected write came to, built from the mutations' own responses.";
+                readonly description: "What an item holds once a write is done, read off the write's own responses — and, for an\nexpected write, what each mutation it sent came to.\n\nEvery write verb and every item a copy lands answers one, with no request added for it: a\nfield the write kept is what the read before it held. `version` is `null` where the source\ncannot vouch for a token from its write's responses — a GitHub board for an item it has just\nwritten, a stdio-hosted plugin, an in-memory source — and otherwise the token a read would\nthen give.";
                 readonly properties: {
                     readonly parts: {
-                        readonly description: "One per mutation sent, in the order sent.";
+                        readonly description: "One per mutation an expected write sent, in the order sent — absent for a write made\nwithout `--expect`.";
                         readonly items: {
                             readonly $ref: "#/$defs/WritePart";
                         };
-                        readonly type: "array";
+                        readonly type: readonly ["array", "null"];
+                    };
+                    readonly priority: {
+                        readonly anyOf: readonly [{
+                            readonly $ref: "#/$defs/Priority";
+                        }, {
+                            readonly type: "null";
+                        }];
+                        readonly default: null;
+                        readonly description: "A task's priority after the write — `null` for a project or a document, which carry\nnone, and where an expected write that failed cannot say.";
+                    };
+                    readonly status: {
+                        readonly anyOf: readonly [{
+                            readonly $ref: "#/$defs/Status";
+                        }, {
+                            readonly type: "null";
+                        }];
+                        readonly default: null;
+                        readonly description: "The item's status after the write, exactly as `task show` spells it — `null` for a\ndocument, which has none, and where an expected write that failed cannot say.";
                     };
                     readonly version: {
-                        readonly description: "The task's version after the write, where the last response determines it.";
+                        readonly description: "The item's version after the write, where the write's responses determine it.";
                         readonly type: readonly ["string", "null"];
                     };
                 };
-                readonly required: readonly ["parts"];
                 readonly type: "object";
             };
         };
@@ -4831,7 +5411,7 @@ export declare const runtimeSchemas: {
                 }, {
                     readonly type: "null";
                 }];
-                readonly description: "What each mutation the write sent came to, and the version it left the task at — for a\nsource that reports its writes' parts.";
+                readonly description: "What the item holds once the write is done — its version, status and priority — and,\nfor a write made with `--expect` on a source that reports its writes' parts, what each\nmutation it sent came to. Absent for a dry run and for an item nothing was written to\nor read of.";
             };
             readonly spent: {
                 readonly anyOf: readonly [{
@@ -4985,6 +5565,30 @@ export declare const runtimeSchemas: {
                     readonly type: "string";
                 }];
             };
+            readonly Priority: {
+                readonly description: "How much a task matters, in the one vocabulary every source is normalised into.\n\nFive values, most pressing first after [`None`](Self::None): Linear's own priority has\nexactly these, and a source whose backend has none of its own maps its representation\nonto them. `none` is a value rather than an absent field, because \"no priority is set\" is\nsomething a person sets — writing `none` clears a priority — and a reader tells it apart\nfrom nothing by the value alone.";
+                readonly oneOf: readonly [{
+                    readonly const: "none";
+                    readonly description: "No priority is set.";
+                    readonly type: "string";
+                }, {
+                    readonly const: "urgent";
+                    readonly description: "Drop everything for it.";
+                    readonly type: "string";
+                }, {
+                    readonly const: "high";
+                    readonly description: "Next, before the rest.";
+                    readonly type: "string";
+                }, {
+                    readonly const: "medium";
+                    readonly description: "In its turn.";
+                    readonly type: "string";
+                }, {
+                    readonly const: "low";
+                    readonly description: "When there is nothing more pressing.";
+                    readonly type: "string";
+                }];
+            };
             readonly SourceName: {
                 readonly description: "The name a configuration document gives one configured source.";
                 readonly pattern: "^[a-z0-9][a-z0-9-]*$";
@@ -5010,6 +5614,57 @@ export declare const runtimeSchemas: {
                 readonly required: readonly ["requests", "budgets"];
                 readonly type: "object";
             };
+            readonly Status: {
+                readonly description: "A source's status, kept in both normalised and original form.\n\n`category` is what every filter compares against; `name` is the source's own\nwording, preserved so display never flattens \"In Review\" into \"In Progress\".";
+                readonly properties: {
+                    readonly category: {
+                        readonly $ref: "#/$defs/StatusCategory";
+                        readonly description: "The normalised value filters compare against.";
+                    };
+                    readonly name: {
+                        readonly description: "The source's own label for this status.";
+                        readonly type: "string";
+                    };
+                };
+                readonly required: readonly ["category", "name"];
+                readonly type: "object";
+            };
+            readonly StatusCategory: {
+                readonly description: "The normalised status vocabulary shared across every source.";
+                readonly oneOf: readonly [{
+                    readonly const: "draft";
+                    readonly description: "Written down but not yet committed to as work.";
+                    readonly type: "string";
+                }, {
+                    readonly const: "backlog";
+                    readonly description: "Known about, not yet accepted as ready to work.";
+                    readonly type: "string";
+                }, {
+                    readonly const: "todo";
+                    readonly description: "Accepted and ready to be picked up, and nothing has claimed it.";
+                    readonly type: "string";
+                }, {
+                    readonly const: "queued";
+                    readonly description: "Claimed by work that will do it, and not yet started.";
+                    readonly type: "string";
+                }, {
+                    readonly const: "in-progress";
+                    readonly description: "Being worked on.";
+                    readonly type: "string";
+                }, {
+                    readonly const: "done";
+                    readonly description: "Finished.";
+                    readonly type: "string";
+                }, {
+                    readonly const: "cancelled";
+                    readonly description: "Abandoned.";
+                    readonly type: "string";
+                }, {
+                    readonly const: "unknown";
+                    readonly description: "The source reported a status this vocabulary cannot place.";
+                    readonly type: "string";
+                }];
+            };
             readonly WriteFallback: {
                 readonly description: "That an expected write read its target before writing, and why.";
                 readonly properties: {
@@ -5086,21 +5741,38 @@ export declare const runtimeSchemas: {
                 readonly type: "object";
             };
             readonly WriteResult: {
-                readonly description: "What each mutation of an expected write came to, built from the mutations' own responses.";
+                readonly description: "What an item holds once a write is done, read off the write's own responses — and, for an\nexpected write, what each mutation it sent came to.\n\nEvery write verb and every item a copy lands answers one, with no request added for it: a\nfield the write kept is what the read before it held. `version` is `null` where the source\ncannot vouch for a token from its write's responses — a GitHub board for an item it has just\nwritten, a stdio-hosted plugin, an in-memory source — and otherwise the token a read would\nthen give.";
                 readonly properties: {
                     readonly parts: {
-                        readonly description: "One per mutation sent, in the order sent.";
+                        readonly description: "One per mutation an expected write sent, in the order sent — absent for a write made\nwithout `--expect`.";
                         readonly items: {
                             readonly $ref: "#/$defs/WritePart";
                         };
-                        readonly type: "array";
+                        readonly type: readonly ["array", "null"];
+                    };
+                    readonly priority: {
+                        readonly anyOf: readonly [{
+                            readonly $ref: "#/$defs/Priority";
+                        }, {
+                            readonly type: "null";
+                        }];
+                        readonly default: null;
+                        readonly description: "A task's priority after the write — `null` for a project or a document, which carry\nnone, and where an expected write that failed cannot say.";
+                    };
+                    readonly status: {
+                        readonly anyOf: readonly [{
+                            readonly $ref: "#/$defs/Status";
+                        }, {
+                            readonly type: "null";
+                        }];
+                        readonly default: null;
+                        readonly description: "The item's status after the write, exactly as `task show` spells it — `null` for a\ndocument, which has none, and where an expected write that failed cannot say.";
                     };
                     readonly version: {
-                        readonly description: "The task's version after the write, where the last response determines it.";
+                        readonly description: "The item's version after the write, where the write's responses determine it.";
                         readonly type: readonly ["string", "null"];
                     };
                 };
-                readonly required: readonly ["parts"];
                 readonly type: "object";
             };
         };
@@ -5119,13 +5791,21 @@ export declare const runtimeSchemas: {
                 }];
                 readonly description: "That the write had to read its target first, and why — absent when it sent only its\nmutations.";
             };
+            readonly held: {
+                readonly anyOf: readonly [{
+                    readonly $ref: "#/$defs/WriteResult";
+                }, {
+                    readonly type: "null";
+                }];
+                readonly description: "What the destination item a copy refused to write held, as the copy's read of it\nbefore writing found it — present only for a refusal made after that read, such as\n`target-task-origin`.";
+            };
             readonly result: {
                 readonly anyOf: readonly [{
                     readonly $ref: "#/$defs/WriteResult";
                 }, {
                     readonly type: "null";
                 }];
-                readonly description: "What each mutation the write sent came to, and the version it left the task at — for a\nsource that reports its writes' parts.";
+                readonly description: "What the item holds once the write is done — its version, status and priority — and,\nfor a write made with `--expect` on a source that reports its writes' parts, what each\nmutation it sent came to. Absent for a dry run and for an item nothing was written to\nor read of.";
             };
             readonly spent: {
                 readonly anyOf: readonly [{
@@ -6724,11 +7404,19 @@ export declare const runtimeSchemas: {
                     readonly const: "match";
                     readonly description: "A search of the destination by the caller's `--match-by`.";
                     readonly type: "string";
+                }, {
+                    readonly const: "intent";
+                    readonly description: "The item the destination holds under the key of a create an earlier attempt of this\ncopy recorded its intent for, at `onetaskgraph.creating`: that attempt's create,\nfinished rather than made twice.";
+                    readonly type: "string";
                 }];
             };
             readonly CreatesIn: {
                 readonly description: "Where a create would file a task's issue.";
                 readonly properties: {
+                    readonly refused: {
+                        readonly description: "Why the destination's own policy on where it creates — a GitHub Projects source's\n`creation_owners` — would refuse a create there, as the copy's refusal says it; absent\nwhen it would not. The locate itself never fails for it.";
+                        readonly type: readonly ["string", "null"];
+                    };
                     readonly repository: {
                         readonly $ref: "#/$defs/Repository";
                         readonly description: "The repository, as a normalized origin `host/owner/name`.";
@@ -6942,6 +7630,30 @@ export declare const runtimeSchemas: {
                 readonly description: "One caller-owned metadata key: `<namespace>.<name>`, at least two non-empty segments\nseparated by dots, whose first segment is not [`MetadataKey::RESERVED_NAMESPACE`].\n\nValidated wherever one is built, deserialized included, so a plugin handed one never has\nto ask whether it names a key this product owns.";
                 readonly type: "string";
             };
+            readonly Priority: {
+                readonly description: "How much a task matters, in the one vocabulary every source is normalised into.\n\nFive values, most pressing first after [`None`](Self::None): Linear's own priority has\nexactly these, and a source whose backend has none of its own maps its representation\nonto them. `none` is a value rather than an absent field, because \"no priority is set\" is\nsomething a person sets — writing `none` clears a priority — and a reader tells it apart\nfrom nothing by the value alone.";
+                readonly oneOf: readonly [{
+                    readonly const: "none";
+                    readonly description: "No priority is set.";
+                    readonly type: "string";
+                }, {
+                    readonly const: "urgent";
+                    readonly description: "Drop everything for it.";
+                    readonly type: "string";
+                }, {
+                    readonly const: "high";
+                    readonly description: "Next, before the rest.";
+                    readonly type: "string";
+                }, {
+                    readonly const: "medium";
+                    readonly description: "In its turn.";
+                    readonly type: "string";
+                }, {
+                    readonly const: "low";
+                    readonly description: "When there is nothing more pressing.";
+                    readonly type: "string";
+                }];
+            };
             readonly Spent: {
                 readonly description: "What one command spent, summed over the sources in it that meter their own requests.\n\n**Source-owned.** Every figure is what a source said it sent and spent while the command\nran, read through [`TaskSource::metering`](onetaskgraph_plugin_api::TaskSource::metering)\nbefore the command and again after it. The engine adds the differences up by name and\ninterprets none of them, which is why the budget and unit names are open vocabulary.";
                 readonly properties: {
@@ -6962,6 +7674,57 @@ export declare const runtimeSchemas: {
                 readonly required: readonly ["requests", "budgets"];
                 readonly type: "object";
             };
+            readonly Status: {
+                readonly description: "A source's status, kept in both normalised and original form.\n\n`category` is what every filter compares against; `name` is the source's own\nwording, preserved so display never flattens \"In Review\" into \"In Progress\".";
+                readonly properties: {
+                    readonly category: {
+                        readonly $ref: "#/$defs/StatusCategory";
+                        readonly description: "The normalised value filters compare against.";
+                    };
+                    readonly name: {
+                        readonly description: "The source's own label for this status.";
+                        readonly type: "string";
+                    };
+                };
+                readonly required: readonly ["category", "name"];
+                readonly type: "object";
+            };
+            readonly StatusCategory: {
+                readonly description: "The normalised status vocabulary shared across every source.";
+                readonly oneOf: readonly [{
+                    readonly const: "draft";
+                    readonly description: "Written down but not yet committed to as work.";
+                    readonly type: "string";
+                }, {
+                    readonly const: "backlog";
+                    readonly description: "Known about, not yet accepted as ready to work.";
+                    readonly type: "string";
+                }, {
+                    readonly const: "todo";
+                    readonly description: "Accepted and ready to be picked up, and nothing has claimed it.";
+                    readonly type: "string";
+                }, {
+                    readonly const: "queued";
+                    readonly description: "Claimed by work that will do it, and not yet started.";
+                    readonly type: "string";
+                }, {
+                    readonly const: "in-progress";
+                    readonly description: "Being worked on.";
+                    readonly type: "string";
+                }, {
+                    readonly const: "done";
+                    readonly description: "Finished.";
+                    readonly type: "string";
+                }, {
+                    readonly const: "cancelled";
+                    readonly description: "Abandoned.";
+                    readonly type: "string";
+                }, {
+                    readonly const: "unknown";
+                    readonly description: "The source reported a status this vocabulary cannot place.";
+                    readonly type: "string";
+                }];
+            };
             readonly WriteFallback: {
                 readonly description: "That an expected write read its target before writing, and why.";
                 readonly properties: {
@@ -7038,21 +7801,38 @@ export declare const runtimeSchemas: {
                 readonly type: "object";
             };
             readonly WriteResult: {
-                readonly description: "What each mutation of an expected write came to, built from the mutations' own responses.";
+                readonly description: "What an item holds once a write is done, read off the write's own responses — and, for an\nexpected write, what each mutation it sent came to.\n\nEvery write verb and every item a copy lands answers one, with no request added for it: a\nfield the write kept is what the read before it held. `version` is `null` where the source\ncannot vouch for a token from its write's responses — a GitHub board for an item it has just\nwritten, a stdio-hosted plugin, an in-memory source — and otherwise the token a read would\nthen give.";
                 readonly properties: {
                     readonly parts: {
-                        readonly description: "One per mutation sent, in the order sent.";
+                        readonly description: "One per mutation an expected write sent, in the order sent — absent for a write made\nwithout `--expect`.";
                         readonly items: {
                             readonly $ref: "#/$defs/WritePart";
                         };
-                        readonly type: "array";
+                        readonly type: readonly ["array", "null"];
+                    };
+                    readonly priority: {
+                        readonly anyOf: readonly [{
+                            readonly $ref: "#/$defs/Priority";
+                        }, {
+                            readonly type: "null";
+                        }];
+                        readonly default: null;
+                        readonly description: "A task's priority after the write — `null` for a project or a document, which carry\nnone, and where an expected write that failed cannot say.";
+                    };
+                    readonly status: {
+                        readonly anyOf: readonly [{
+                            readonly $ref: "#/$defs/Status";
+                        }, {
+                            readonly type: "null";
+                        }];
+                        readonly default: null;
+                        readonly description: "The item's status after the write, exactly as `task show` spells it — `null` for a\ndocument, which has none, and where an expected write that failed cannot say.";
                     };
                     readonly version: {
-                        readonly description: "The task's version after the write, where the last response determines it.";
+                        readonly description: "The item's version after the write, where the write's responses determine it.";
                         readonly type: readonly ["string", "null"];
                     };
                 };
-                readonly required: readonly ["parts"];
                 readonly type: "object";
             };
         };
@@ -16373,6 +17153,30 @@ export declare const runtimeSchemas: {
                 readonly description: "One item, qualified by the source it came from.\n\nRendered `<source>:<native>` and parsed by splitting on the **first** colon,\nso a native id may contain colons freely.";
                 readonly type: "string";
             };
+            readonly Priority: {
+                readonly description: "How much a task matters, in the one vocabulary every source is normalised into.\n\nFive values, most pressing first after [`None`](Self::None): Linear's own priority has\nexactly these, and a source whose backend has none of its own maps its representation\nonto them. `none` is a value rather than an absent field, because \"no priority is set\" is\nsomething a person sets — writing `none` clears a priority — and a reader tells it apart\nfrom nothing by the value alone.";
+                readonly oneOf: readonly [{
+                    readonly const: "none";
+                    readonly description: "No priority is set.";
+                    readonly type: "string";
+                }, {
+                    readonly const: "urgent";
+                    readonly description: "Drop everything for it.";
+                    readonly type: "string";
+                }, {
+                    readonly const: "high";
+                    readonly description: "Next, before the rest.";
+                    readonly type: "string";
+                }, {
+                    readonly const: "medium";
+                    readonly description: "In its turn.";
+                    readonly type: "string";
+                }, {
+                    readonly const: "low";
+                    readonly description: "When there is nothing more pressing.";
+                    readonly type: "string";
+                }];
+            };
             readonly Spent: {
                 readonly description: "What one command spent, summed over the sources in it that meter their own requests.\n\n**Source-owned.** Every figure is what a source said it sent and spent while the command\nran, read through [`TaskSource::metering`](onetaskgraph_plugin_api::TaskSource::metering)\nbefore the command and again after it. The engine adds the differences up by name and\ninterprets none of them, which is why the budget and unit names are open vocabulary.";
                 readonly properties: {
@@ -16393,6 +17197,57 @@ export declare const runtimeSchemas: {
                 readonly required: readonly ["requests", "budgets"];
                 readonly type: "object";
             };
+            readonly Status: {
+                readonly description: "A source's status, kept in both normalised and original form.\n\n`category` is what every filter compares against; `name` is the source's own\nwording, preserved so display never flattens \"In Review\" into \"In Progress\".";
+                readonly properties: {
+                    readonly category: {
+                        readonly $ref: "#/$defs/StatusCategory";
+                        readonly description: "The normalised value filters compare against.";
+                    };
+                    readonly name: {
+                        readonly description: "The source's own label for this status.";
+                        readonly type: "string";
+                    };
+                };
+                readonly required: readonly ["category", "name"];
+                readonly type: "object";
+            };
+            readonly StatusCategory: {
+                readonly description: "The normalised status vocabulary shared across every source.";
+                readonly oneOf: readonly [{
+                    readonly const: "draft";
+                    readonly description: "Written down but not yet committed to as work.";
+                    readonly type: "string";
+                }, {
+                    readonly const: "backlog";
+                    readonly description: "Known about, not yet accepted as ready to work.";
+                    readonly type: "string";
+                }, {
+                    readonly const: "todo";
+                    readonly description: "Accepted and ready to be picked up, and nothing has claimed it.";
+                    readonly type: "string";
+                }, {
+                    readonly const: "queued";
+                    readonly description: "Claimed by work that will do it, and not yet started.";
+                    readonly type: "string";
+                }, {
+                    readonly const: "in-progress";
+                    readonly description: "Being worked on.";
+                    readonly type: "string";
+                }, {
+                    readonly const: "done";
+                    readonly description: "Finished.";
+                    readonly type: "string";
+                }, {
+                    readonly const: "cancelled";
+                    readonly description: "Abandoned.";
+                    readonly type: "string";
+                }, {
+                    readonly const: "unknown";
+                    readonly description: "The source reported a status this vocabulary cannot place.";
+                    readonly type: "string";
+                }];
+            };
             readonly WriteFallback: {
                 readonly description: "That an expected write read its target before writing, and why.";
                 readonly properties: {
@@ -16469,21 +17324,38 @@ export declare const runtimeSchemas: {
                 readonly type: "object";
             };
             readonly WriteResult: {
-                readonly description: "What each mutation of an expected write came to, built from the mutations' own responses.";
+                readonly description: "What an item holds once a write is done, read off the write's own responses — and, for an\nexpected write, what each mutation it sent came to.\n\nEvery write verb and every item a copy lands answers one, with no request added for it: a\nfield the write kept is what the read before it held. `version` is `null` where the source\ncannot vouch for a token from its write's responses — a GitHub board for an item it has just\nwritten, a stdio-hosted plugin, an in-memory source — and otherwise the token a read would\nthen give.";
                 readonly properties: {
                     readonly parts: {
-                        readonly description: "One per mutation sent, in the order sent.";
+                        readonly description: "One per mutation an expected write sent, in the order sent — absent for a write made\nwithout `--expect`.";
                         readonly items: {
                             readonly $ref: "#/$defs/WritePart";
                         };
-                        readonly type: "array";
+                        readonly type: readonly ["array", "null"];
+                    };
+                    readonly priority: {
+                        readonly anyOf: readonly [{
+                            readonly $ref: "#/$defs/Priority";
+                        }, {
+                            readonly type: "null";
+                        }];
+                        readonly default: null;
+                        readonly description: "A task's priority after the write — `null` for a project or a document, which carry\nnone, and where an expected write that failed cannot say.";
+                    };
+                    readonly status: {
+                        readonly anyOf: readonly [{
+                            readonly $ref: "#/$defs/Status";
+                        }, {
+                            readonly type: "null";
+                        }];
+                        readonly default: null;
+                        readonly description: "The item's status after the write, exactly as `task show` spells it — `null` for a\ndocument, which has none, and where an expected write that failed cannot say.";
                     };
                     readonly version: {
-                        readonly description: "The task's version after the write, where the last response determines it.";
+                        readonly description: "The item's version after the write, where the write's responses determine it.";
                         readonly type: readonly ["string", "null"];
                     };
                 };
-                readonly required: readonly ["parts"];
                 readonly type: "object";
             };
         };
@@ -18154,6 +19026,57 @@ export declare const runtimeSchemas: {
                 readonly required: readonly ["requests", "budgets"];
                 readonly type: "object";
             };
+            readonly Status: {
+                readonly description: "A source's status, kept in both normalised and original form.\n\n`category` is what every filter compares against; `name` is the source's own\nwording, preserved so display never flattens \"In Review\" into \"In Progress\".";
+                readonly properties: {
+                    readonly category: {
+                        readonly $ref: "#/$defs/StatusCategory";
+                        readonly description: "The normalised value filters compare against.";
+                    };
+                    readonly name: {
+                        readonly description: "The source's own label for this status.";
+                        readonly type: "string";
+                    };
+                };
+                readonly required: readonly ["category", "name"];
+                readonly type: "object";
+            };
+            readonly StatusCategory: {
+                readonly description: "The normalised status vocabulary shared across every source.";
+                readonly oneOf: readonly [{
+                    readonly const: "draft";
+                    readonly description: "Written down but not yet committed to as work.";
+                    readonly type: "string";
+                }, {
+                    readonly const: "backlog";
+                    readonly description: "Known about, not yet accepted as ready to work.";
+                    readonly type: "string";
+                }, {
+                    readonly const: "todo";
+                    readonly description: "Accepted and ready to be picked up, and nothing has claimed it.";
+                    readonly type: "string";
+                }, {
+                    readonly const: "queued";
+                    readonly description: "Claimed by work that will do it, and not yet started.";
+                    readonly type: "string";
+                }, {
+                    readonly const: "in-progress";
+                    readonly description: "Being worked on.";
+                    readonly type: "string";
+                }, {
+                    readonly const: "done";
+                    readonly description: "Finished.";
+                    readonly type: "string";
+                }, {
+                    readonly const: "cancelled";
+                    readonly description: "Abandoned.";
+                    readonly type: "string";
+                }, {
+                    readonly const: "unknown";
+                    readonly description: "The source reported a status this vocabulary cannot place.";
+                    readonly type: "string";
+                }];
+            };
             readonly WriteFallback: {
                 readonly description: "That an expected write read its target before writing, and why.";
                 readonly properties: {
@@ -18230,21 +19153,38 @@ export declare const runtimeSchemas: {
                 readonly type: "object";
             };
             readonly WriteResult: {
-                readonly description: "What each mutation of an expected write came to, built from the mutations' own responses.";
+                readonly description: "What an item holds once a write is done, read off the write's own responses — and, for an\nexpected write, what each mutation it sent came to.\n\nEvery write verb and every item a copy lands answers one, with no request added for it: a\nfield the write kept is what the read before it held. `version` is `null` where the source\ncannot vouch for a token from its write's responses — a GitHub board for an item it has just\nwritten, a stdio-hosted plugin, an in-memory source — and otherwise the token a read would\nthen give.";
                 readonly properties: {
                     readonly parts: {
-                        readonly description: "One per mutation sent, in the order sent.";
+                        readonly description: "One per mutation an expected write sent, in the order sent — absent for a write made\nwithout `--expect`.";
                         readonly items: {
                             readonly $ref: "#/$defs/WritePart";
                         };
-                        readonly type: "array";
+                        readonly type: readonly ["array", "null"];
+                    };
+                    readonly priority: {
+                        readonly anyOf: readonly [{
+                            readonly $ref: "#/$defs/Priority";
+                        }, {
+                            readonly type: "null";
+                        }];
+                        readonly default: null;
+                        readonly description: "A task's priority after the write — `null` for a project or a document, which carry\nnone, and where an expected write that failed cannot say.";
+                    };
+                    readonly status: {
+                        readonly anyOf: readonly [{
+                            readonly $ref: "#/$defs/Status";
+                        }, {
+                            readonly type: "null";
+                        }];
+                        readonly default: null;
+                        readonly description: "The item's status after the write, exactly as `task show` spells it — `null` for a\ndocument, which has none, and where an expected write that failed cannot say.";
                     };
                     readonly version: {
-                        readonly description: "The task's version after the write, where the last response determines it.";
+                        readonly description: "The item's version after the write, where the write's responses determine it.";
                         readonly type: readonly ["string", "null"];
                     };
                 };
-                readonly required: readonly ["parts"];
                 readonly type: "object";
             };
         };
@@ -18689,6 +19629,30 @@ export declare const runtimeSchemas: {
                 readonly description: "One item, qualified by the source it came from.\n\nRendered `<source>:<native>` and parsed by splitting on the **first** colon,\nso a native id may contain colons freely.";
                 readonly type: "string";
             };
+            readonly Priority: {
+                readonly description: "How much a task matters, in the one vocabulary every source is normalised into.\n\nFive values, most pressing first after [`None`](Self::None): Linear's own priority has\nexactly these, and a source whose backend has none of its own maps its representation\nonto them. `none` is a value rather than an absent field, because \"no priority is set\" is\nsomething a person sets — writing `none` clears a priority — and a reader tells it apart\nfrom nothing by the value alone.";
+                readonly oneOf: readonly [{
+                    readonly const: "none";
+                    readonly description: "No priority is set.";
+                    readonly type: "string";
+                }, {
+                    readonly const: "urgent";
+                    readonly description: "Drop everything for it.";
+                    readonly type: "string";
+                }, {
+                    readonly const: "high";
+                    readonly description: "Next, before the rest.";
+                    readonly type: "string";
+                }, {
+                    readonly const: "medium";
+                    readonly description: "In its turn.";
+                    readonly type: "string";
+                }, {
+                    readonly const: "low";
+                    readonly description: "When there is nothing more pressing.";
+                    readonly type: "string";
+                }];
+            };
             readonly SourceName: {
                 readonly description: "The name a configuration document gives one configured source.";
                 readonly pattern: "^[a-z0-9][a-z0-9-]*$";
@@ -18841,21 +19805,38 @@ export declare const runtimeSchemas: {
                 readonly type: "object";
             };
             readonly WriteResult: {
-                readonly description: "What each mutation of an expected write came to, built from the mutations' own responses.";
+                readonly description: "What an item holds once a write is done, read off the write's own responses — and, for an\nexpected write, what each mutation it sent came to.\n\nEvery write verb and every item a copy lands answers one, with no request added for it: a\nfield the write kept is what the read before it held. `version` is `null` where the source\ncannot vouch for a token from its write's responses — a GitHub board for an item it has just\nwritten, a stdio-hosted plugin, an in-memory source — and otherwise the token a read would\nthen give.";
                 readonly properties: {
                     readonly parts: {
-                        readonly description: "One per mutation sent, in the order sent.";
+                        readonly description: "One per mutation an expected write sent, in the order sent — absent for a write made\nwithout `--expect`.";
                         readonly items: {
                             readonly $ref: "#/$defs/WritePart";
                         };
-                        readonly type: "array";
+                        readonly type: readonly ["array", "null"];
+                    };
+                    readonly priority: {
+                        readonly anyOf: readonly [{
+                            readonly $ref: "#/$defs/Priority";
+                        }, {
+                            readonly type: "null";
+                        }];
+                        readonly default: null;
+                        readonly description: "A task's priority after the write — `null` for a project or a document, which carry\nnone, and where an expected write that failed cannot say.";
+                    };
+                    readonly status: {
+                        readonly anyOf: readonly [{
+                            readonly $ref: "#/$defs/Status";
+                        }, {
+                            readonly type: "null";
+                        }];
+                        readonly default: null;
+                        readonly description: "The item's status after the write, exactly as `task show` spells it — `null` for a\ndocument, which has none, and where an expected write that failed cannot say.";
                     };
                     readonly version: {
-                        readonly description: "The task's version after the write, where the last response determines it.";
+                        readonly description: "The item's version after the write, where the write's responses determine it.";
                         readonly type: readonly ["string", "null"];
                     };
                 };
-                readonly required: readonly ["parts"];
                 readonly type: "object";
             };
         };
@@ -19997,21 +20978,38 @@ export declare const runtimeSchemas: {
                 readonly type: "object";
             };
             readonly WriteResult: {
-                readonly description: "What each mutation of an expected write came to, built from the mutations' own responses.";
+                readonly description: "What an item holds once a write is done, read off the write's own responses — and, for an\nexpected write, what each mutation it sent came to.\n\nEvery write verb and every item a copy lands answers one, with no request added for it: a\nfield the write kept is what the read before it held. `version` is `null` where the source\ncannot vouch for a token from its write's responses — a GitHub board for an item it has just\nwritten, a stdio-hosted plugin, an in-memory source — and otherwise the token a read would\nthen give.";
                 readonly properties: {
                     readonly parts: {
-                        readonly description: "One per mutation sent, in the order sent.";
+                        readonly description: "One per mutation an expected write sent, in the order sent — absent for a write made\nwithout `--expect`.";
                         readonly items: {
                             readonly $ref: "#/$defs/WritePart";
                         };
-                        readonly type: "array";
+                        readonly type: readonly ["array", "null"];
+                    };
+                    readonly priority: {
+                        readonly anyOf: readonly [{
+                            readonly $ref: "#/$defs/Priority";
+                        }, {
+                            readonly type: "null";
+                        }];
+                        readonly default: null;
+                        readonly description: "A task's priority after the write — `null` for a project or a document, which carry\nnone, and where an expected write that failed cannot say.";
+                    };
+                    readonly status: {
+                        readonly anyOf: readonly [{
+                            readonly $ref: "#/$defs/Status";
+                        }, {
+                            readonly type: "null";
+                        }];
+                        readonly default: null;
+                        readonly description: "The item's status after the write, exactly as `task show` spells it — `null` for a\ndocument, which has none, and where an expected write that failed cannot say.";
                     };
                     readonly version: {
-                        readonly description: "The task's version after the write, where the last response determines it.";
+                        readonly description: "The item's version after the write, where the write's responses determine it.";
                         readonly type: readonly ["string", "null"];
                     };
                 };
-                readonly required: readonly ["parts"];
                 readonly type: "object";
             };
         };