@onetaskgraph/sdk 0.12.13 → 0.13.0

package/dist/index.js

@@ -7193,7 +7193,7 @@ var binaryCommands = [
 ];
 
 // src/generated/models.ts
-var SCHEMA_BUNDLE_VERSION = 50;
+var SCHEMA_BUNDLE_VERSION = 51;
 
 // src/generated/schemas.ts
 var runtimeSchemas = {
@@ -8326,6 +8326,13 @@ reader already written against this shape can ignore.`,
         ],
         type: "object"
       },
+      GlobalId: {
+        description: `One item, qualified by the source it came from.
+
+Rendered \`<source>:<native>\` and parsed by splitting on the **first** colon,
+so a native id may contain colons freely.`,
+        type: "string"
+      },
       NativeId: {
         description: `A source's own opaque identifier for one item.
 
@@ -8334,6 +8341,42 @@ is, colons included. The engine parses a qualified id by splitting on the
 *first* colon precisely so this stays true.`,
         type: "string"
       },
+      Priority: {
+        description: `How much a task matters, in the one vocabulary every source is normalised into.
+
+Five values, most pressing first after [\`None\`](Self::None): Linear's own priority has
+exactly these, and a source whose backend has none of its own maps its representation
+onto them. \`none\` is a value rather than an absent field, because "no priority is set" is
+something a person sets — writing \`none\` clears a priority — and a reader tells it apart
+from nothing by the value alone.`,
+        oneOf: [
+          {
+            const: "none",
+            description: "No priority is set.",
+            type: "string"
+          },
+          {
+            const: "urgent",
+            description: "Drop everything for it.",
+            type: "string"
+          },
+          {
+            const: "high",
+            description: "Next, before the rest.",
+            type: "string"
+          },
+          {
+            const: "medium",
+            description: "In its turn.",
+            type: "string"
+          },
+          {
+            const: "low",
+            description: "When there is nothing more pressing.",
+            type: "string"
+          }
+        ]
+      },
       Spent: {
         description: `What one command spent, summed over the sources in it that meter their own requests.
 
@@ -8362,6 +8405,72 @@ interprets none of them, which is why the budget and unit names are open vocabul
         ],
         type: "object"
       },
+      Status: {
+        description: `A source's status, kept in both normalised and original form.
+
+\`category\` is what every filter compares against; \`name\` is the source's own
+wording, preserved so display never flattens "In Review" into "In Progress".`,
+        properties: {
+          category: {
+            $ref: "#/$defs/StatusCategory",
+            description: "The normalised value filters compare against."
+          },
+          name: {
+            description: "The source's own label for this status.",
+            type: "string"
+          }
+        },
+        required: [
+          "category",
+          "name"
+        ],
+        type: "object"
+      },
+      StatusCategory: {
+        description: "The normalised status vocabulary shared across every source.",
+        oneOf: [
+          {
+            const: "draft",
+            description: "Written down but not yet committed to as work.",
+            type: "string"
+          },
+          {
+            const: "backlog",
+            description: "Known about, not yet accepted as ready to work.",
+            type: "string"
+          },
+          {
+            const: "todo",
+            description: "Accepted and ready to be picked up, and nothing has claimed it.",
+            type: "string"
+          },
+          {
+            const: "queued",
+            description: "Claimed by work that will do it, and not yet started.",
+            type: "string"
+          },
+          {
+            const: "in-progress",
+            description: "Being worked on.",
+            type: "string"
+          },
+          {
+            const: "done",
+            description: "Finished.",
+            type: "string"
+          },
+          {
+            const: "cancelled",
+            description: "Abandoned.",
+            type: "string"
+          },
+          {
+            const: "unknown",
+            description: "The source reported a status this vocabulary cannot place.",
+            type: "string"
+          }
+        ]
+      },
       WriteFallback: {
         description: "That an expected write read its target before writing, and why.",
         properties: {
@@ -8459,26 +8568,57 @@ Never sent again: doing so could apply it twice.`,
         type: "object"
       },
       WriteResult: {
-        description: "What each mutation of an expected write came to, built from the mutations' own responses.",
+        description: `What an item holds once a write is done, read off the write's own responses — and, for an
+expected write, what each mutation it sent came to.
+
+Every write verb and every item a copy lands answers one, with no request added for it: a
+field the write kept is what the read before it held. \`version\` is \`null\` where the source
+cannot vouch for a token from its write's responses — a GitHub board for an item it has just
+written, a stdio-hosted plugin, an in-memory source — and otherwise the token a read would
+then give.`,
         properties: {
           parts: {
-            description: "One per mutation sent, in the order sent.",
+            description: "One per mutation an expected write sent, in the order sent — absent for a write made\nwithout `--expect`.",
             items: {
               $ref: "#/$defs/WritePart"
             },
-            type: "array"
+            type: [
+              "array",
+              "null"
+            ]
+          },
+          priority: {
+            anyOf: [
+              {
+                $ref: "#/$defs/Priority"
+              },
+              {
+                type: "null"
+              }
+            ],
+            default: null,
+            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."
+          },
+          status: {
+            anyOf: [
+              {
+                $ref: "#/$defs/Status"
+              },
+              {
+                type: "null"
+              }
+            ],
+            default: null,
+            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."
           },
           version: {
-            description: "The task's version after the write, where the last response determines it.",
+            description: "The item's version after the write, where the write's responses determine it.",
             type: [
               "string",
               "null"
             ]
           }
         },
-        required: [
-          "parts"
-        ],
         type: "object"
       }
     },
@@ -8522,6 +8662,17 @@ Never sent again: doing so could apply it twice.`,
 Opaque, as every [\`NativeId\`] is, and never qualified: a comment is addressed through
 the qualified id of the task it is on, so its own id needs no source of its own.`
       },
+      item: {
+        anyOf: [
+          {
+            $ref: "#/$defs/GlobalId"
+          },
+          {
+            type: "null"
+          }
+        ],
+        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."
+      },
       origin: {
         anyOf: [
           {
@@ -9429,6 +9580,11 @@ so as [\`NoCounterpart\`] instead.`,
             const: "match",
             description: "A search of the destination by the caller's `--match-by`.",
             type: "string"
+          },
+          {
+            const: "intent",
+            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.",
+            type: "string"
           }
         ]
       },
@@ -9897,6 +10053,11 @@ so as [\`NoCounterpart\`] instead.`,
             const: "match",
             description: "A search of the destination by the caller's `--match-by`.",
             type: "string"
+          },
+          {
+            const: "intent",
+            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.",
+            type: "string"
           }
         ]
       },
@@ -10001,6 +10162,60 @@ so a native id may contain colons freely.`,
         ],
         type: "object"
       },
+      Priority: {
+        description: `How much a task matters, in the one vocabulary every source is normalised into.
+
+Five values, most pressing first after [\`None\`](Self::None): Linear's own priority has
+exactly these, and a source whose backend has none of its own maps its representation
+onto them. \`none\` is a value rather than an absent field, because "no priority is set" is
+something a person sets — writing \`none\` clears a priority — and a reader tells it apart
+from nothing by the value alone.`,
+        oneOf: [
+          {
+            const: "none",
+            description: "No priority is set.",
+            type: "string"
+          },
+          {
+            const: "urgent",
+            description: "Drop everything for it.",
+            type: "string"
+          },
+          {
+            const: "high",
+            description: "Next, before the rest.",
+            type: "string"
+          },
+          {
+            const: "medium",
+            description: "In its turn.",
+            type: "string"
+          },
+          {
+            const: "low",
+            description: "When there is nothing more pressing.",
+            type: "string"
+          }
+        ]
+      },
+      PriorityCondition: {
+        description: "What a guarded copy found a counterpart's priority at, and whether that met the condition.",
+        properties: {
+          held: {
+            $ref: "#/$defs/Priority",
+            description: "The counterpart's priority, as the copy's own pre-write read held it."
+          },
+          met: {
+            description: "Whether that priority is one the condition names.",
+            type: "boolean"
+          }
+        },
+        required: [
+          "held",
+          "met"
+        ],
+        type: "object"
+      },
       SourceName: {
         description: "The name a configuration document gives one configured source.",
         pattern: "^[a-z0-9][a-z0-9-]*$",
@@ -10034,58 +10249,142 @@ interprets none of them, which is why the budget and unit names are open vocabul
         ],
         type: "object"
       },
-      WriteFallback: {
-        description: "That an expected write read its target before writing, and why.",
+      Status: {
+        description: `A source's status, kept in both normalised and original form.
+
+\`category\` is what every filter compares against; \`name\` is the source's own
+wording, preserved so display never flattens "In Review" into "In Progress".`,
         properties: {
-          read: {
-            description: "Always `true`: the write made one read.",
-            type: "boolean"
+          category: {
+            $ref: "#/$defs/StatusCategory",
+            description: "The normalised value filters compare against."
           },
-          reason: {
-            description: "Why it could not take what it needed from the cache.",
+          name: {
+            description: "The source's own label for this status.",
             type: "string"
           }
         },
         required: [
-          "read",
-          "reason"
+          "category",
+          "name"
         ],
         type: "object"
       },
-      WritePart: {
-        description: "One mutation of an expected write.",
+      StatusCategory: {
+        description: "The normalised status vocabulary shared across every source.",
         oneOf: [
           {
-            description: "The backend answered that it was applied.",
-            properties: {
-              outcome: {
-                const: "landed",
-                type: "string"
-              }
-            },
-            required: [
-              "outcome"
-            ],
-            type: "object"
+            const: "draft",
+            description: "Written down but not yet committed to as work.",
+            type: "string"
           },
           {
-            description: "The backend answered that it was refused.",
-            properties: {
-              error: {
-                description: "What the backend said.",
-                type: "string"
-              },
-              outcome: {
-                const: "rejected",
-                type: "string"
-              },
-              stale: {
-                default: false,
-                description: `Whether it was refused because an id the write took from a primed context — an
-item's node id, a field's or an option's — no longer resolves. Such a part is
-sent again once, after one read.`,
-                type: "boolean"
-              }
+            const: "backlog",
+            description: "Known about, not yet accepted as ready to work.",
+            type: "string"
+          },
+          {
+            const: "todo",
+            description: "Accepted and ready to be picked up, and nothing has claimed it.",
+            type: "string"
+          },
+          {
+            const: "queued",
+            description: "Claimed by work that will do it, and not yet started.",
+            type: "string"
+          },
+          {
+            const: "in-progress",
+            description: "Being worked on.",
+            type: "string"
+          },
+          {
+            const: "done",
+            description: "Finished.",
+            type: "string"
+          },
+          {
+            const: "cancelled",
+            description: "Abandoned.",
+            type: "string"
+          },
+          {
+            const: "unknown",
+            description: "The source reported a status this vocabulary cannot place.",
+            type: "string"
+          }
+        ]
+      },
+      StatusCondition: {
+        description: "What a guarded copy found a counterpart's status at, and whether that met the condition.",
+        properties: {
+          held: {
+            $ref: "#/$defs/StatusCategory",
+            description: "The counterpart's status category, as the copy's own pre-write read held it."
+          },
+          met: {
+            description: "Whether that category is one the condition names.",
+            type: "boolean"
+          }
+        },
+        required: [
+          "held",
+          "met"
+        ],
+        type: "object"
+      },
+      WriteFallback: {
+        description: "That an expected write read its target before writing, and why.",
+        properties: {
+          read: {
+            description: "Always `true`: the write made one read.",
+            type: "boolean"
+          },
+          reason: {
+            description: "Why it could not take what it needed from the cache.",
+            type: "string"
+          }
+        },
+        required: [
+          "read",
+          "reason"
+        ],
+        type: "object"
+      },
+      WritePart: {
+        description: "One mutation of an expected write.",
+        oneOf: [
+          {
+            description: "The backend answered that it was applied.",
+            properties: {
+              outcome: {
+                const: "landed",
+                type: "string"
+              }
+            },
+            required: [
+              "outcome"
+            ],
+            type: "object"
+          },
+          {
+            description: "The backend answered that it was refused.",
+            properties: {
+              error: {
+                description: "What the backend said.",
+                type: "string"
+              },
+              outcome: {
+                const: "rejected",
+                type: "string"
+              },
+              stale: {
+                default: false,
+                description: `Whether it was refused because an id the write took from a primed context — an
+item's node id, a field's or an option's — no longer resolves. Such a part is
+sent again once, after one read.`,
+                type: "boolean"
+              }
             },
             required: [
               "outcome",
@@ -10131,26 +10430,57 @@ Never sent again: doing so could apply it twice.`,
         type: "object"
       },
       WriteResult: {
-        description: "What each mutation of an expected write came to, built from the mutations' own responses.",
+        description: `What an item holds once a write is done, read off the write's own responses — and, for an
+expected write, what each mutation it sent came to.
+
+Every write verb and every item a copy lands answers one, with no request added for it: a
+field the write kept is what the read before it held. \`version\` is \`null\` where the source
+cannot vouch for a token from its write's responses — a GitHub board for an item it has just
+written, a stdio-hosted plugin, an in-memory source — and otherwise the token a read would
+then give.`,
         properties: {
           parts: {
-            description: "One per mutation sent, in the order sent.",
+            description: "One per mutation an expected write sent, in the order sent — absent for a write made\nwithout `--expect`.",
             items: {
               $ref: "#/$defs/WritePart"
             },
-            type: "array"
+            type: [
+              "array",
+              "null"
+            ]
+          },
+          priority: {
+            anyOf: [
+              {
+                $ref: "#/$defs/Priority"
+              },
+              {
+                type: "null"
+              }
+            ],
+            default: null,
+            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."
+          },
+          status: {
+            anyOf: [
+              {
+                $ref: "#/$defs/Status"
+              },
+              {
+                type: "null"
+              }
+            ],
+            default: null,
+            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."
           },
           version: {
-            description: "The task's version after the write, where the last response determines it.",
+            description: "The item's version after the write, where the write's responses determine it.",
             type: [
               "string",
               "null"
             ]
           }
         },
-        required: [
-          "parts"
-        ],
         type: "object"
       }
     },
@@ -10383,6 +10713,17 @@ exits \`4\`. Copying the item again once it has settled lands it.`,
         description: `That the write had to read its target first, and why — absent when it sent only its
 mutations.`
       },
+      held: {
+        anyOf: [
+          {
+            $ref: "#/$defs/WriteResult"
+          },
+          {
+            type: "null"
+          }
+        ],
+        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`."
+      },
       placed: {
         anyOf: [
           {
@@ -10400,6 +10741,17 @@ included, so a would-be create still says where it would go; absent for a copy i
 a source with none, whose output is what it always was, and for an orphan, which was
 not placed at all.`
       },
+      priority_condition: {
+        anyOf: [
+          {
+            $ref: "#/$defs/PriorityCondition"
+          },
+          {
+            type: "null"
+          }
+        ],
+        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."
+      },
       result: {
         anyOf: [
           {
@@ -10409,8 +10761,10 @@ not placed at all.`
             type: "null"
           }
         ],
-        description: `What each mutation the write sent came to, and the version it left the task at — for a
-source that reports its writes' parts.`
+        description: `What the item holds once the write is done — its version, status and priority — and,
+for a write made with \`--expect\` on a source that reports its writes' parts, what each
+mutation it sent came to. Absent for a dry run and for an item nothing was written to
+or read of.`
       },
       source: {
         $ref: "#/$defs/GlobalId",
@@ -10427,6 +10781,17 @@ source that reports its writes' parts.`
         ],
         description: `What the write spent at the sources that meter their own requests — the fallback's
 read included.`
+      },
+      status_condition: {
+        anyOf: [
+          {
+            $ref: "#/$defs/StatusCondition"
+          },
+          {
+            type: "null"
+          }
+        ],
+        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."
       }
     },
     required: [
@@ -10768,6 +11133,17 @@ exits \`4\`. Copying the item again once it has settled lands it.`,
             description: `That the write had to read its target first, and why — absent when it sent only its
 mutations.`
           },
+          held: {
+            anyOf: [
+              {
+                $ref: "#/$defs/WriteResult"
+              },
+              {
+                type: "null"
+              }
+            ],
+            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`."
+          },
           placed: {
             anyOf: [
               {
@@ -10785,6 +11161,17 @@ included, so a would-be create still says where it would go; absent for a copy i
 a source with none, whose output is what it always was, and for an orphan, which was
 not placed at all.`
           },
+          priority_condition: {
+            anyOf: [
+              {
+                $ref: "#/$defs/PriorityCondition"
+              },
+              {
+                type: "null"
+              }
+            ],
+            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."
+          },
           result: {
             anyOf: [
               {
@@ -10794,8 +11181,10 @@ not placed at all.`
                 type: "null"
               }
             ],
-            description: `What each mutation the write sent came to, and the version it left the task at — for a
-source that reports its writes' parts.`
+            description: `What the item holds once the write is done — its version, status and priority — and,
+for a write made with \`--expect\` on a source that reports its writes' parts, what each
+mutation it sent came to. Absent for a dry run and for an item nothing was written to
+or read of.`
           },
           source: {
             $ref: "#/$defs/GlobalId",
@@ -10812,6 +11201,17 @@ source that reports its writes' parts.`
             ],
             description: `What the write spent at the sources that meter their own requests — the fallback's
 read included.`
+          },
+          status_condition: {
+            anyOf: [
+              {
+                $ref: "#/$defs/StatusCondition"
+              },
+              {
+                type: "null"
+              }
+            ],
+            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."
           }
         },
         required: [
@@ -10852,6 +11252,11 @@ so as [\`NoCounterpart\`] instead.`,
             const: "match",
             description: "A search of the destination by the caller's `--match-by`.",
             type: "string"
+          },
+          {
+            const: "intent",
+            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.",
+            type: "string"
           }
         ]
       },
@@ -11073,6 +11478,60 @@ so a native id may contain colons freely.`,
         ],
         type: "object"
       },
+      Priority: {
+        description: `How much a task matters, in the one vocabulary every source is normalised into.
+
+Five values, most pressing first after [\`None\`](Self::None): Linear's own priority has
+exactly these, and a source whose backend has none of its own maps its representation
+onto them. \`none\` is a value rather than an absent field, because "no priority is set" is
+something a person sets — writing \`none\` clears a priority — and a reader tells it apart
+from nothing by the value alone.`,
+        oneOf: [
+          {
+            const: "none",
+            description: "No priority is set.",
+            type: "string"
+          },
+          {
+            const: "urgent",
+            description: "Drop everything for it.",
+            type: "string"
+          },
+          {
+            const: "high",
+            description: "Next, before the rest.",
+            type: "string"
+          },
+          {
+            const: "medium",
+            description: "In its turn.",
+            type: "string"
+          },
+          {
+            const: "low",
+            description: "When there is nothing more pressing.",
+            type: "string"
+          }
+        ]
+      },
+      PriorityCondition: {
+        description: "What a guarded copy found a counterpart's priority at, and whether that met the condition.",
+        properties: {
+          held: {
+            $ref: "#/$defs/Priority",
+            description: "The counterpart's priority, as the copy's own pre-write read held it."
+          },
+          met: {
+            description: "Whether that priority is one the condition names.",
+            type: "boolean"
+          }
+        },
+        required: [
+          "held",
+          "met"
+        ],
+        type: "object"
+      },
       SourceName: {
         description: "The name a configuration document gives one configured source.",
         pattern: "^[a-z0-9][a-z0-9-]*$",
@@ -11106,6 +11565,27 @@ interprets none of them, which is why the budget and unit names are open vocabul
         ],
         type: "object"
       },
+      Status: {
+        description: `A source's status, kept in both normalised and original form.
+
+\`category\` is what every filter compares against; \`name\` is the source's own
+wording, preserved so display never flattens "In Review" into "In Progress".`,
+        properties: {
+          category: {
+            $ref: "#/$defs/StatusCategory",
+            description: "The normalised value filters compare against."
+          },
+          name: {
+            description: "The source's own label for this status.",
+            type: "string"
+          }
+        },
+        required: [
+          "category",
+          "name"
+        ],
+        type: "object"
+      },
       StatusCategory: {
         description: "The normalised status vocabulary shared across every source.",
         oneOf: [
@@ -11151,6 +11631,24 @@ interprets none of them, which is why the budget and unit names are open vocabul
           }
         ]
       },
+      StatusCondition: {
+        description: "What a guarded copy found a counterpart's status at, and whether that met the condition.",
+        properties: {
+          held: {
+            $ref: "#/$defs/StatusCategory",
+            description: "The counterpart's status category, as the copy's own pre-write read held it."
+          },
+          met: {
+            description: "Whether that category is one the condition names.",
+            type: "boolean"
+          }
+        },
+        required: [
+          "held",
+          "met"
+        ],
+        type: "object"
+      },
       WriteFallback: {
         description: "That an expected write read its target before writing, and why.",
         properties: {
@@ -11248,26 +11746,57 @@ Never sent again: doing so could apply it twice.`,
         type: "object"
       },
       WriteResult: {
-        description: "What each mutation of an expected write came to, built from the mutations' own responses.",
+        description: `What an item holds once a write is done, read off the write's own responses — and, for an
+expected write, what each mutation it sent came to.
+
+Every write verb and every item a copy lands answers one, with no request added for it: a
+field the write kept is what the read before it held. \`version\` is \`null\` where the source
+cannot vouch for a token from its write's responses — a GitHub board for an item it has just
+written, a stdio-hosted plugin, an in-memory source — and otherwise the token a read would
+then give.`,
         properties: {
           parts: {
-            description: "One per mutation sent, in the order sent.",
+            description: "One per mutation an expected write sent, in the order sent — absent for a write made\nwithout `--expect`.",
             items: {
               $ref: "#/$defs/WritePart"
             },
-            type: "array"
+            type: [
+              "array",
+              "null"
+            ]
+          },
+          priority: {
+            anyOf: [
+              {
+                $ref: "#/$defs/Priority"
+              },
+              {
+                type: "null"
+              }
+            ],
+            default: null,
+            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."
+          },
+          status: {
+            anyOf: [
+              {
+                $ref: "#/$defs/Status"
+              },
+              {
+                type: "null"
+              }
+            ],
+            default: null,
+            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."
           },
           version: {
-            description: "The task's version after the write, where the last response determines it.",
+            description: "The item's version after the write, where the write's responses determine it.",
             type: [
               "string",
               "null"
             ]
           }
         },
-        required: [
-          "parts"
-        ],
         type: "object"
       }
     },
@@ -11403,10 +11932,42 @@ so as [\`NoCounterpart\`] instead.`,
         const: "match",
         description: "A search of the destination by the caller's `--match-by`.",
         type: "string"
+      },
+      {
+        const: "intent",
+        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.",
+        type: "string"
       }
     ],
     title: "CopyVia"
   },
+  CreateSettings: {
+    $schema: "https://json-schema.org/draft/2020-12/schema",
+    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.",
+    properties: {
+      create_lease_seconds: {
+        description: "Seconds an intent to create stays the holder's own; 120 when absent.",
+        format: "uint64",
+        minimum: 0,
+        type: [
+          "integer",
+          "null"
+        ]
+      },
+      create_quiescence_seconds: {
+        description: `Seconds after an intent was first taken that a retry waits for the earlier create to be
+listed; 120 when absent.`,
+        format: "uint64",
+        minimum: 0,
+        type: [
+          "integer",
+          "null"
+        ]
+      }
+    },
+    title: "CreateSettings",
+    type: "object"
+  },
   CredentialLayer: {
     $schema: "https://json-schema.org/draft/2020-12/schema",
     description: "Which layer answered for one credential name.",
@@ -11464,6 +12025,42 @@ is, colons included. The engine parses a qualified id by splitting on the
 *first* colon precisely so this stays true.`,
         type: "string"
       },
+      Priority: {
+        description: `How much a task matters, in the one vocabulary every source is normalised into.
+
+Five values, most pressing first after [\`None\`](Self::None): Linear's own priority has
+exactly these, and a source whose backend has none of its own maps its representation
+onto them. \`none\` is a value rather than an absent field, because "no priority is set" is
+something a person sets — writing \`none\` clears a priority — and a reader tells it apart
+from nothing by the value alone.`,
+        oneOf: [
+          {
+            const: "none",
+            description: "No priority is set.",
+            type: "string"
+          },
+          {
+            const: "urgent",
+            description: "Drop everything for it.",
+            type: "string"
+          },
+          {
+            const: "high",
+            description: "Next, before the rest.",
+            type: "string"
+          },
+          {
+            const: "medium",
+            description: "In its turn.",
+            type: "string"
+          },
+          {
+            const: "low",
+            description: "When there is nothing more pressing.",
+            type: "string"
+          }
+        ]
+      },
       Spent: {
         description: `What one command spent, summed over the sources in it that meter their own requests.
 
@@ -11492,6 +12089,72 @@ interprets none of them, which is why the budget and unit names are open vocabul
         ],
         type: "object"
       },
+      Status: {
+        description: `A source's status, kept in both normalised and original form.
+
+\`category\` is what every filter compares against; \`name\` is the source's own
+wording, preserved so display never flattens "In Review" into "In Progress".`,
+        properties: {
+          category: {
+            $ref: "#/$defs/StatusCategory",
+            description: "The normalised value filters compare against."
+          },
+          name: {
+            description: "The source's own label for this status.",
+            type: "string"
+          }
+        },
+        required: [
+          "category",
+          "name"
+        ],
+        type: "object"
+      },
+      StatusCategory: {
+        description: "The normalised status vocabulary shared across every source.",
+        oneOf: [
+          {
+            const: "draft",
+            description: "Written down but not yet committed to as work.",
+            type: "string"
+          },
+          {
+            const: "backlog",
+            description: "Known about, not yet accepted as ready to work.",
+            type: "string"
+          },
+          {
+            const: "todo",
+            description: "Accepted and ready to be picked up, and nothing has claimed it.",
+            type: "string"
+          },
+          {
+            const: "queued",
+            description: "Claimed by work that will do it, and not yet started.",
+            type: "string"
+          },
+          {
+            const: "in-progress",
+            description: "Being worked on.",
+            type: "string"
+          },
+          {
+            const: "done",
+            description: "Finished.",
+            type: "string"
+          },
+          {
+            const: "cancelled",
+            description: "Abandoned.",
+            type: "string"
+          },
+          {
+            const: "unknown",
+            description: "The source reported a status this vocabulary cannot place.",
+            type: "string"
+          }
+        ]
+      },
       WriteFallback: {
         description: "That an expected write read its target before writing, and why.",
         properties: {
@@ -11589,26 +12252,57 @@ Never sent again: doing so could apply it twice.`,
         type: "object"
       },
       WriteResult: {
-        description: "What each mutation of an expected write came to, built from the mutations' own responses.",
+        description: `What an item holds once a write is done, read off the write's own responses — and, for an
+expected write, what each mutation it sent came to.
+
+Every write verb and every item a copy lands answers one, with no request added for it: a
+field the write kept is what the read before it held. \`version\` is \`null\` where the source
+cannot vouch for a token from its write's responses — a GitHub board for an item it has just
+written, a stdio-hosted plugin, an in-memory source — and otherwise the token a read would
+then give.`,
         properties: {
           parts: {
-            description: "One per mutation sent, in the order sent.",
+            description: "One per mutation an expected write sent, in the order sent — absent for a write made\nwithout `--expect`.",
             items: {
               $ref: "#/$defs/WritePart"
             },
-            type: "array"
+            type: [
+              "array",
+              "null"
+            ]
+          },
+          priority: {
+            anyOf: [
+              {
+                $ref: "#/$defs/Priority"
+              },
+              {
+                type: "null"
+              }
+            ],
+            default: null,
+            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."
+          },
+          status: {
+            anyOf: [
+              {
+                $ref: "#/$defs/Status"
+              },
+              {
+                type: "null"
+              }
+            ],
+            default: null,
+            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."
           },
           version: {
-            description: "The task's version after the write, where the last response determines it.",
+            description: "The item's version after the write, where the write's responses determine it.",
             type: [
               "string",
               "null"
             ]
           }
         },
-        required: [
-          "parts"
-        ],
         type: "object"
       }
     },
@@ -13685,6 +14379,42 @@ name and the layer are reported and the value never is.`
         ],
         type: "object"
       },
+      Priority: {
+        description: `How much a task matters, in the one vocabulary every source is normalised into.
+
+Five values, most pressing first after [\`None\`](Self::None): Linear's own priority has
+exactly these, and a source whose backend has none of its own maps its representation
+onto them. \`none\` is a value rather than an absent field, because "no priority is set" is
+something a person sets — writing \`none\` clears a priority — and a reader tells it apart
+from nothing by the value alone.`,
+        oneOf: [
+          {
+            const: "none",
+            description: "No priority is set.",
+            type: "string"
+          },
+          {
+            const: "urgent",
+            description: "Drop everything for it.",
+            type: "string"
+          },
+          {
+            const: "high",
+            description: "Next, before the rest.",
+            type: "string"
+          },
+          {
+            const: "medium",
+            description: "In its turn.",
+            type: "string"
+          },
+          {
+            const: "low",
+            description: "When there is nothing more pressing.",
+            type: "string"
+          }
+        ]
+      },
       Spent: {
         description: `What one command spent, summed over the sources in it that meter their own requests.
 
@@ -13713,6 +14443,72 @@ interprets none of them, which is why the budget and unit names are open vocabul
         ],
         type: "object"
       },
+      Status: {
+        description: `A source's status, kept in both normalised and original form.
+
+\`category\` is what every filter compares against; \`name\` is the source's own
+wording, preserved so display never flattens "In Review" into "In Progress".`,
+        properties: {
+          category: {
+            $ref: "#/$defs/StatusCategory",
+            description: "The normalised value filters compare against."
+          },
+          name: {
+            description: "The source's own label for this status.",
+            type: "string"
+          }
+        },
+        required: [
+          "category",
+          "name"
+        ],
+        type: "object"
+      },
+      StatusCategory: {
+        description: "The normalised status vocabulary shared across every source.",
+        oneOf: [
+          {
+            const: "draft",
+            description: "Written down but not yet committed to as work.",
+            type: "string"
+          },
+          {
+            const: "backlog",
+            description: "Known about, not yet accepted as ready to work.",
+            type: "string"
+          },
+          {
+            const: "todo",
+            description: "Accepted and ready to be picked up, and nothing has claimed it.",
+            type: "string"
+          },
+          {
+            const: "queued",
+            description: "Claimed by work that will do it, and not yet started.",
+            type: "string"
+          },
+          {
+            const: "in-progress",
+            description: "Being worked on.",
+            type: "string"
+          },
+          {
+            const: "done",
+            description: "Finished.",
+            type: "string"
+          },
+          {
+            const: "cancelled",
+            description: "Abandoned.",
+            type: "string"
+          },
+          {
+            const: "unknown",
+            description: "The source reported a status this vocabulary cannot place.",
+            type: "string"
+          }
+        ]
+      },
       WriteFallback: {
         description: "That an expected write read its target before writing, and why.",
         properties: {
@@ -13810,26 +14606,57 @@ Never sent again: doing so could apply it twice.`,
         type: "object"
       },
       WriteResult: {
-        description: "What each mutation of an expected write came to, built from the mutations' own responses.",
+        description: `What an item holds once a write is done, read off the write's own responses — and, for an
+expected write, what each mutation it sent came to.
+
+Every write verb and every item a copy lands answers one, with no request added for it: a
+field the write kept is what the read before it held. \`version\` is \`null\` where the source
+cannot vouch for a token from its write's responses — a GitHub board for an item it has just
+written, a stdio-hosted plugin, an in-memory source — and otherwise the token a read would
+then give.`,
         properties: {
           parts: {
-            description: "One per mutation sent, in the order sent.",
+            description: "One per mutation an expected write sent, in the order sent — absent for a write made\nwithout `--expect`.",
             items: {
               $ref: "#/$defs/WritePart"
             },
-            type: "array"
+            type: [
+              "array",
+              "null"
+            ]
+          },
+          priority: {
+            anyOf: [
+              {
+                $ref: "#/$defs/Priority"
+              },
+              {
+                type: "null"
+              }
+            ],
+            default: null,
+            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."
+          },
+          status: {
+            anyOf: [
+              {
+                $ref: "#/$defs/Status"
+              },
+              {
+                type: "null"
+              }
+            ],
+            default: null,
+            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."
           },
           version: {
-            description: "The task's version after the write, where the last response determines it.",
+            description: "The item's version after the write, where the write's responses determine it.",
             type: [
               "string",
               "null"
             ]
           }
         },
-        required: [
-          "parts"
-        ],
         type: "object"
       }
     },
@@ -13857,8 +14684,10 @@ mutations.`
             type: "null"
           }
         ],
-        description: `What each mutation the write sent came to, and the version it left the task at — for a
-source that reports its writes' parts.`
+        description: `What the item holds once the write is done — its version, status and priority — and,
+for a write made with \`--expect\` on a source that reports its writes' parts, what each
+mutation it sent came to. Absent for a dry run and for an item nothing was written to
+or read of.`
       },
       spent: {
         anyOf: [
@@ -14060,6 +14889,42 @@ later.`,
           }
         ]
       },
+      Priority: {
+        description: `How much a task matters, in the one vocabulary every source is normalised into.
+
+Five values, most pressing first after [\`None\`](Self::None): Linear's own priority has
+exactly these, and a source whose backend has none of its own maps its representation
+onto them. \`none\` is a value rather than an absent field, because "no priority is set" is
+something a person sets — writing \`none\` clears a priority — and a reader tells it apart
+from nothing by the value alone.`,
+        oneOf: [
+          {
+            const: "none",
+            description: "No priority is set.",
+            type: "string"
+          },
+          {
+            const: "urgent",
+            description: "Drop everything for it.",
+            type: "string"
+          },
+          {
+            const: "high",
+            description: "Next, before the rest.",
+            type: "string"
+          },
+          {
+            const: "medium",
+            description: "In its turn.",
+            type: "string"
+          },
+          {
+            const: "low",
+            description: "When there is nothing more pressing.",
+            type: "string"
+          }
+        ]
+      },
       SourceName: {
         description: "The name a configuration document gives one configured source.",
         pattern: "^[a-z0-9][a-z0-9-]*$",
@@ -14093,6 +14958,72 @@ interprets none of them, which is why the budget and unit names are open vocabul
         ],
         type: "object"
       },
+      Status: {
+        description: `A source's status, kept in both normalised and original form.
+
+\`category\` is what every filter compares against; \`name\` is the source's own
+wording, preserved so display never flattens "In Review" into "In Progress".`,
+        properties: {
+          category: {
+            $ref: "#/$defs/StatusCategory",
+            description: "The normalised value filters compare against."
+          },
+          name: {
+            description: "The source's own label for this status.",
+            type: "string"
+          }
+        },
+        required: [
+          "category",
+          "name"
+        ],
+        type: "object"
+      },
+      StatusCategory: {
+        description: "The normalised status vocabulary shared across every source.",
+        oneOf: [
+          {
+            const: "draft",
+            description: "Written down but not yet committed to as work.",
+            type: "string"
+          },
+          {
+            const: "backlog",
+            description: "Known about, not yet accepted as ready to work.",
+            type: "string"
+          },
+          {
+            const: "todo",
+            description: "Accepted and ready to be picked up, and nothing has claimed it.",
+            type: "string"
+          },
+          {
+            const: "queued",
+            description: "Claimed by work that will do it, and not yet started.",
+            type: "string"
+          },
+          {
+            const: "in-progress",
+            description: "Being worked on.",
+            type: "string"
+          },
+          {
+            const: "done",
+            description: "Finished.",
+            type: "string"
+          },
+          {
+            const: "cancelled",
+            description: "Abandoned.",
+            type: "string"
+          },
+          {
+            const: "unknown",
+            description: "The source reported a status this vocabulary cannot place.",
+            type: "string"
+          }
+        ]
+      },
       WriteFallback: {
         description: "That an expected write read its target before writing, and why.",
         properties: {
@@ -14190,26 +15121,57 @@ Never sent again: doing so could apply it twice.`,
         type: "object"
       },
       WriteResult: {
-        description: "What each mutation of an expected write came to, built from the mutations' own responses.",
+        description: `What an item holds once a write is done, read off the write's own responses — and, for an
+expected write, what each mutation it sent came to.
+
+Every write verb and every item a copy lands answers one, with no request added for it: a
+field the write kept is what the read before it held. \`version\` is \`null\` where the source
+cannot vouch for a token from its write's responses — a GitHub board for an item it has just
+written, a stdio-hosted plugin, an in-memory source — and otherwise the token a read would
+then give.`,
         properties: {
           parts: {
-            description: "One per mutation sent, in the order sent.",
+            description: "One per mutation an expected write sent, in the order sent — absent for a write made\nwithout `--expect`.",
             items: {
               $ref: "#/$defs/WritePart"
             },
-            type: "array"
+            type: [
+              "array",
+              "null"
+            ]
+          },
+          priority: {
+            anyOf: [
+              {
+                $ref: "#/$defs/Priority"
+              },
+              {
+                type: "null"
+              }
+            ],
+            default: null,
+            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."
+          },
+          status: {
+            anyOf: [
+              {
+                $ref: "#/$defs/Status"
+              },
+              {
+                type: "null"
+              }
+            ],
+            default: null,
+            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."
           },
           version: {
-            description: "The task's version after the write, where the last response determines it.",
+            description: "The item's version after the write, where the write's responses determine it.",
             type: [
               "string",
               "null"
             ]
           }
         },
-        required: [
-          "parts"
-        ],
         type: "object"
       }
     },
@@ -14232,6 +15194,17 @@ Never sent again: doing so could apply it twice.`,
         description: `That the write had to read its target first, and why — absent when it sent only its
 mutations.`
       },
+      held: {
+        anyOf: [
+          {
+            $ref: "#/$defs/WriteResult"
+          },
+          {
+            type: "null"
+          }
+        ],
+        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`."
+      },
       result: {
         anyOf: [
           {
@@ -14241,8 +15214,10 @@ mutations.`
             type: "null"
           }
         ],
-        description: `What each mutation the write sent came to, and the version it left the task at — for a
-source that reports its writes' parts.`
+        description: `What the item holds once the write is done — its version, status and priority — and,
+for a write made with \`--expect\` on a source that reports its writes' parts, what each
+mutation it sent came to. Absent for a dry run and for an item nothing was written to
+or read of.`
       },
       spent: {
         anyOf: [
@@ -16337,12 +17312,24 @@ so as [\`NoCounterpart\`] instead.`,
             const: "match",
             description: "A search of the destination by the caller's `--match-by`.",
             type: "string"
+          },
+          {
+            const: "intent",
+            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.",
+            type: "string"
           }
         ]
       },
       CreatesIn: {
         description: "Where a create would file a task's issue.",
         properties: {
+          refused: {
+            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.",
+            type: [
+              "string",
+              "null"
+            ]
+          },
           repository: {
             $ref: "#/$defs/Repository",
             description: "The repository, as a normalized origin `host/owner/name`."
@@ -16620,6 +17607,42 @@ absolute path, so a reader can print the path or read the contents out.`,
         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.",
         type: "string"
       },
+      Priority: {
+        description: `How much a task matters, in the one vocabulary every source is normalised into.
+
+Five values, most pressing first after [\`None\`](Self::None): Linear's own priority has
+exactly these, and a source whose backend has none of its own maps its representation
+onto them. \`none\` is a value rather than an absent field, because "no priority is set" is
+something a person sets — writing \`none\` clears a priority — and a reader tells it apart
+from nothing by the value alone.`,
+        oneOf: [
+          {
+            const: "none",
+            description: "No priority is set.",
+            type: "string"
+          },
+          {
+            const: "urgent",
+            description: "Drop everything for it.",
+            type: "string"
+          },
+          {
+            const: "high",
+            description: "Next, before the rest.",
+            type: "string"
+          },
+          {
+            const: "medium",
+            description: "In its turn.",
+            type: "string"
+          },
+          {
+            const: "low",
+            description: "When there is nothing more pressing.",
+            type: "string"
+          }
+        ]
+      },
       Spent: {
         description: `What one command spent, summed over the sources in it that meter their own requests.
 
@@ -16648,6 +17671,72 @@ interprets none of them, which is why the budget and unit names are open vocabul
         ],
         type: "object"
       },
+      Status: {
+        description: `A source's status, kept in both normalised and original form.
+
+\`category\` is what every filter compares against; \`name\` is the source's own
+wording, preserved so display never flattens "In Review" into "In Progress".`,
+        properties: {
+          category: {
+            $ref: "#/$defs/StatusCategory",
+            description: "The normalised value filters compare against."
+          },
+          name: {
+            description: "The source's own label for this status.",
+            type: "string"
+          }
+        },
+        required: [
+          "category",
+          "name"
+        ],
+        type: "object"
+      },
+      StatusCategory: {
+        description: "The normalised status vocabulary shared across every source.",
+        oneOf: [
+          {
+            const: "draft",
+            description: "Written down but not yet committed to as work.",
+            type: "string"
+          },
+          {
+            const: "backlog",
+            description: "Known about, not yet accepted as ready to work.",
+            type: "string"
+          },
+          {
+            const: "todo",
+            description: "Accepted and ready to be picked up, and nothing has claimed it.",
+            type: "string"
+          },
+          {
+            const: "queued",
+            description: "Claimed by work that will do it, and not yet started.",
+            type: "string"
+          },
+          {
+            const: "in-progress",
+            description: "Being worked on.",
+            type: "string"
+          },
+          {
+            const: "done",
+            description: "Finished.",
+            type: "string"
+          },
+          {
+            const: "cancelled",
+            description: "Abandoned.",
+            type: "string"
+          },
+          {
+            const: "unknown",
+            description: "The source reported a status this vocabulary cannot place.",
+            type: "string"
+          }
+        ]
+      },
       WriteFallback: {
         description: "That an expected write read its target before writing, and why.",
         properties: {
@@ -16745,26 +17834,57 @@ Never sent again: doing so could apply it twice.`,
         type: "object"
       },
       WriteResult: {
-        description: "What each mutation of an expected write came to, built from the mutations' own responses.",
+        description: `What an item holds once a write is done, read off the write's own responses — and, for an
+expected write, what each mutation it sent came to.
+
+Every write verb and every item a copy lands answers one, with no request added for it: a
+field the write kept is what the read before it held. \`version\` is \`null\` where the source
+cannot vouch for a token from its write's responses — a GitHub board for an item it has just
+written, a stdio-hosted plugin, an in-memory source — and otherwise the token a read would
+then give.`,
         properties: {
           parts: {
-            description: "One per mutation sent, in the order sent.",
+            description: "One per mutation an expected write sent, in the order sent — absent for a write made\nwithout `--expect`.",
             items: {
               $ref: "#/$defs/WritePart"
             },
-            type: "array"
+            type: [
+              "array",
+              "null"
+            ]
+          },
+          priority: {
+            anyOf: [
+              {
+                $ref: "#/$defs/Priority"
+              },
+              {
+                type: "null"
+              }
+            ],
+            default: null,
+            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."
+          },
+          status: {
+            anyOf: [
+              {
+                $ref: "#/$defs/Status"
+              },
+              {
+                type: "null"
+              }
+            ],
+            default: null,
+            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."
           },
           version: {
-            description: "The task's version after the write, where the last response determines it.",
+            description: "The item's version after the write, where the write's responses determine it.",
             type: [
               "string",
               "null"
             ]
           }
         },
-        required: [
-          "parts"
-        ],
         type: "object"
       }
     },
@@ -29813,6 +30933,42 @@ Rendered \`<source>:<native>\` and parsed by splitting on the **first** colon,
 so a native id may contain colons freely.`,
         type: "string"
       },
+      Priority: {
+        description: `How much a task matters, in the one vocabulary every source is normalised into.
+
+Five values, most pressing first after [\`None\`](Self::None): Linear's own priority has
+exactly these, and a source whose backend has none of its own maps its representation
+onto them. \`none\` is a value rather than an absent field, because "no priority is set" is
+something a person sets — writing \`none\` clears a priority — and a reader tells it apart
+from nothing by the value alone.`,
+        oneOf: [
+          {
+            const: "none",
+            description: "No priority is set.",
+            type: "string"
+          },
+          {
+            const: "urgent",
+            description: "Drop everything for it.",
+            type: "string"
+          },
+          {
+            const: "high",
+            description: "Next, before the rest.",
+            type: "string"
+          },
+          {
+            const: "medium",
+            description: "In its turn.",
+            type: "string"
+          },
+          {
+            const: "low",
+            description: "When there is nothing more pressing.",
+            type: "string"
+          }
+        ]
+      },
       Spent: {
         description: `What one command spent, summed over the sources in it that meter their own requests.
 
@@ -29828,18 +30984,84 @@ interprets none of them, which is why the budget and unit names are open vocabul
             },
             type: "array"
           },
-          requests: {
-            description: "How many HTTP requests those sources sent for this command.",
-            format: "uint64",
-            minimum: 0,
-            type: "integer"
+          requests: {
+            description: "How many HTTP requests those sources sent for this command.",
+            format: "uint64",
+            minimum: 0,
+            type: "integer"
+          }
+        },
+        required: [
+          "requests",
+          "budgets"
+        ],
+        type: "object"
+      },
+      Status: {
+        description: `A source's status, kept in both normalised and original form.
+
+\`category\` is what every filter compares against; \`name\` is the source's own
+wording, preserved so display never flattens "In Review" into "In Progress".`,
+        properties: {
+          category: {
+            $ref: "#/$defs/StatusCategory",
+            description: "The normalised value filters compare against."
+          },
+          name: {
+            description: "The source's own label for this status.",
+            type: "string"
+          }
+        },
+        required: [
+          "category",
+          "name"
+        ],
+        type: "object"
+      },
+      StatusCategory: {
+        description: "The normalised status vocabulary shared across every source.",
+        oneOf: [
+          {
+            const: "draft",
+            description: "Written down but not yet committed to as work.",
+            type: "string"
+          },
+          {
+            const: "backlog",
+            description: "Known about, not yet accepted as ready to work.",
+            type: "string"
+          },
+          {
+            const: "todo",
+            description: "Accepted and ready to be picked up, and nothing has claimed it.",
+            type: "string"
+          },
+          {
+            const: "queued",
+            description: "Claimed by work that will do it, and not yet started.",
+            type: "string"
+          },
+          {
+            const: "in-progress",
+            description: "Being worked on.",
+            type: "string"
+          },
+          {
+            const: "done",
+            description: "Finished.",
+            type: "string"
+          },
+          {
+            const: "cancelled",
+            description: "Abandoned.",
+            type: "string"
+          },
+          {
+            const: "unknown",
+            description: "The source reported a status this vocabulary cannot place.",
+            type: "string"
           }
-        },
-        required: [
-          "requests",
-          "budgets"
-        ],
-        type: "object"
+        ]
       },
       WriteFallback: {
         description: "That an expected write read its target before writing, and why.",
@@ -29938,26 +31160,57 @@ Never sent again: doing so could apply it twice.`,
         type: "object"
       },
       WriteResult: {
-        description: "What each mutation of an expected write came to, built from the mutations' own responses.",
+        description: `What an item holds once a write is done, read off the write's own responses — and, for an
+expected write, what each mutation it sent came to.
+
+Every write verb and every item a copy lands answers one, with no request added for it: a
+field the write kept is what the read before it held. \`version\` is \`null\` where the source
+cannot vouch for a token from its write's responses — a GitHub board for an item it has just
+written, a stdio-hosted plugin, an in-memory source — and otherwise the token a read would
+then give.`,
         properties: {
           parts: {
-            description: "One per mutation sent, in the order sent.",
+            description: "One per mutation an expected write sent, in the order sent — absent for a write made\nwithout `--expect`.",
             items: {
               $ref: "#/$defs/WritePart"
             },
-            type: "array"
+            type: [
+              "array",
+              "null"
+            ]
+          },
+          priority: {
+            anyOf: [
+              {
+                $ref: "#/$defs/Priority"
+              },
+              {
+                type: "null"
+              }
+            ],
+            default: null,
+            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."
+          },
+          status: {
+            anyOf: [
+              {
+                $ref: "#/$defs/Status"
+              },
+              {
+                type: "null"
+              }
+            ],
+            default: null,
+            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."
           },
           version: {
-            description: "The task's version after the write, where the last response determines it.",
+            description: "The item's version after the write, where the write's responses determine it.",
             type: [
               "string",
               "null"
             ]
           }
         },
-        required: [
-          "parts"
-        ],
         type: "object"
       }
     },
@@ -32365,6 +33618,72 @@ interprets none of them, which is why the budget and unit names are open vocabul
         ],
         type: "object"
       },
+      Status: {
+        description: `A source's status, kept in both normalised and original form.
+
+\`category\` is what every filter compares against; \`name\` is the source's own
+wording, preserved so display never flattens "In Review" into "In Progress".`,
+        properties: {
+          category: {
+            $ref: "#/$defs/StatusCategory",
+            description: "The normalised value filters compare against."
+          },
+          name: {
+            description: "The source's own label for this status.",
+            type: "string"
+          }
+        },
+        required: [
+          "category",
+          "name"
+        ],
+        type: "object"
+      },
+      StatusCategory: {
+        description: "The normalised status vocabulary shared across every source.",
+        oneOf: [
+          {
+            const: "draft",
+            description: "Written down but not yet committed to as work.",
+            type: "string"
+          },
+          {
+            const: "backlog",
+            description: "Known about, not yet accepted as ready to work.",
+            type: "string"
+          },
+          {
+            const: "todo",
+            description: "Accepted and ready to be picked up, and nothing has claimed it.",
+            type: "string"
+          },
+          {
+            const: "queued",
+            description: "Claimed by work that will do it, and not yet started.",
+            type: "string"
+          },
+          {
+            const: "in-progress",
+            description: "Being worked on.",
+            type: "string"
+          },
+          {
+            const: "done",
+            description: "Finished.",
+            type: "string"
+          },
+          {
+            const: "cancelled",
+            description: "Abandoned.",
+            type: "string"
+          },
+          {
+            const: "unknown",
+            description: "The source reported a status this vocabulary cannot place.",
+            type: "string"
+          }
+        ]
+      },
       WriteFallback: {
         description: "That an expected write read its target before writing, and why.",
         properties: {
@@ -32462,26 +33781,57 @@ Never sent again: doing so could apply it twice.`,
         type: "object"
       },
       WriteResult: {
-        description: "What each mutation of an expected write came to, built from the mutations' own responses.",
+        description: `What an item holds once a write is done, read off the write's own responses — and, for an
+expected write, what each mutation it sent came to.
+
+Every write verb and every item a copy lands answers one, with no request added for it: a
+field the write kept is what the read before it held. \`version\` is \`null\` where the source
+cannot vouch for a token from its write's responses — a GitHub board for an item it has just
+written, a stdio-hosted plugin, an in-memory source — and otherwise the token a read would
+then give.`,
         properties: {
           parts: {
-            description: "One per mutation sent, in the order sent.",
+            description: "One per mutation an expected write sent, in the order sent — absent for a write made\nwithout `--expect`.",
             items: {
               $ref: "#/$defs/WritePart"
             },
-            type: "array"
+            type: [
+              "array",
+              "null"
+            ]
+          },
+          priority: {
+            anyOf: [
+              {
+                $ref: "#/$defs/Priority"
+              },
+              {
+                type: "null"
+              }
+            ],
+            default: null,
+            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."
+          },
+          status: {
+            anyOf: [
+              {
+                $ref: "#/$defs/Status"
+              },
+              {
+                type: "null"
+              }
+            ],
+            default: null,
+            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."
           },
           version: {
-            description: "The task's version after the write, where the last response determines it.",
+            description: "The item's version after the write, where the write's responses determine it.",
             type: [
               "string",
               "null"
             ]
           }
         },
-        required: [
-          "parts"
-        ],
         type: "object"
       }
     },
@@ -33071,6 +34421,42 @@ Rendered \`<source>:<native>\` and parsed by splitting on the **first** colon,
 so a native id may contain colons freely.`,
         type: "string"
       },
+      Priority: {
+        description: `How much a task matters, in the one vocabulary every source is normalised into.
+
+Five values, most pressing first after [\`None\`](Self::None): Linear's own priority has
+exactly these, and a source whose backend has none of its own maps its representation
+onto them. \`none\` is a value rather than an absent field, because "no priority is set" is
+something a person sets — writing \`none\` clears a priority — and a reader tells it apart
+from nothing by the value alone.`,
+        oneOf: [
+          {
+            const: "none",
+            description: "No priority is set.",
+            type: "string"
+          },
+          {
+            const: "urgent",
+            description: "Drop everything for it.",
+            type: "string"
+          },
+          {
+            const: "high",
+            description: "Next, before the rest.",
+            type: "string"
+          },
+          {
+            const: "medium",
+            description: "In its turn.",
+            type: "string"
+          },
+          {
+            const: "low",
+            description: "When there is nothing more pressing.",
+            type: "string"
+          }
+        ]
+      },
       SourceName: {
         description: "The name a configuration document gives one configured source.",
         pattern: "^[a-z0-9][a-z0-9-]*$",
@@ -33267,26 +34653,57 @@ Never sent again: doing so could apply it twice.`,
         type: "object"
       },
       WriteResult: {
-        description: "What each mutation of an expected write came to, built from the mutations' own responses.",
+        description: `What an item holds once a write is done, read off the write's own responses — and, for an
+expected write, what each mutation it sent came to.
+
+Every write verb and every item a copy lands answers one, with no request added for it: a
+field the write kept is what the read before it held. \`version\` is \`null\` where the source
+cannot vouch for a token from its write's responses — a GitHub board for an item it has just
+written, a stdio-hosted plugin, an in-memory source — and otherwise the token a read would
+then give.`,
         properties: {
           parts: {
-            description: "One per mutation sent, in the order sent.",
+            description: "One per mutation an expected write sent, in the order sent — absent for a write made\nwithout `--expect`.",
             items: {
               $ref: "#/$defs/WritePart"
             },
-            type: "array"
+            type: [
+              "array",
+              "null"
+            ]
+          },
+          priority: {
+            anyOf: [
+              {
+                $ref: "#/$defs/Priority"
+              },
+              {
+                type: "null"
+              }
+            ],
+            default: null,
+            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."
+          },
+          status: {
+            anyOf: [
+              {
+                $ref: "#/$defs/Status"
+              },
+              {
+                type: "null"
+              }
+            ],
+            default: null,
+            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."
           },
           version: {
-            description: "The task's version after the write, where the last response determines it.",
+            description: "The item's version after the write, where the write's responses determine it.",
             type: [
               "string",
               "null"
             ]
           }
         },
-        required: [
-          "parts"
-        ],
         type: "object"
       }
     },
@@ -34870,26 +36287,57 @@ Never sent again: doing so could apply it twice.`,
         type: "object"
       },
       WriteResult: {
-        description: "What each mutation of an expected write came to, built from the mutations' own responses.",
+        description: `What an item holds once a write is done, read off the write's own responses — and, for an
+expected write, what each mutation it sent came to.
+
+Every write verb and every item a copy lands answers one, with no request added for it: a
+field the write kept is what the read before it held. \`version\` is \`null\` where the source
+cannot vouch for a token from its write's responses — a GitHub board for an item it has just
+written, a stdio-hosted plugin, an in-memory source — and otherwise the token a read would
+then give.`,
         properties: {
           parts: {
-            description: "One per mutation sent, in the order sent.",
+            description: "One per mutation an expected write sent, in the order sent — absent for a write made\nwithout `--expect`.",
             items: {
               $ref: "#/$defs/WritePart"
             },
-            type: "array"
+            type: [
+              "array",
+              "null"
+            ]
+          },
+          priority: {
+            anyOf: [
+              {
+                $ref: "#/$defs/Priority"
+              },
+              {
+                type: "null"
+              }
+            ],
+            default: null,
+            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."
+          },
+          status: {
+            anyOf: [
+              {
+                $ref: "#/$defs/Status"
+              },
+              {
+                type: "null"
+              }
+            ],
+            default: null,
+            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."
           },
           version: {
-            description: "The task's version after the write, where the last response determines it.",
+            description: "The item's version after the write, where the write's responses determine it.",
             type: [
               "string",
               "null"
             ]
           }
         },
-        required: [
-          "parts"
-        ],
         type: "object"
       }
     },
@@ -35456,6 +36904,7 @@ refusal can be printed wherever the write was asked for.`,
 // src/client.ts
 var projectGraphDirections = ["auto", "td", "lr"];
 var statusPolicies = ["source", "preserve-destination"];
+var otherwiseChoices = ["refuse", "preserve-destination"];
 
 class OnetaskgraphExecutionError extends Error {
   exitCode;
@@ -35884,8 +37333,22 @@ function taskCopyFlags(options) {
   if (options.create !== undefined && typeof options.create !== "boolean") {
     throw new TypeError("taskCopy: create must be a boolean");
   }
+  const conditions = [];
+  for (const status of stringList("taskCopy", "whenDestinationStatus", options.whenDestinationStatus)) {
+    conditions.push("--when-destination-status", status);
+  }
+  if (options.otherwise !== undefined) {
+    if (!otherwiseChoices.some((choice) => choice === options.otherwise)) {
+      throw new TypeError(`taskCopy: otherwise must be ${otherwiseChoices.join(" or ")}`);
+    }
+    conditions.push("--otherwise", options.otherwise);
+  }
+  for (const priority of stringList("taskCopy", "whenDestinationPriority", options.whenDestinationPriority)) {
+    conditions.push("--when-destination-priority", priority);
+  }
   return [
     ...copyFlags("taskCopy", options),
+    ...conditions,
     ...options.create ? ["--create"] : [],
     ...options.targetTask === undefined ? [] : ["--target-task", stringOption("taskCopy", "targetTask", options.targetTask)],
     ...expectFlags("taskCopy", options)
@@ -36379,7 +37842,7 @@ function assertCompleteCommandSurface() {
 }
 
 // src/index.ts
-var VERSION = "0.12.13";
+var VERSION = "0.13.0";
 export {
   taskUpdateOptionFlags,
   taskUpdateFlags,
@@ -36387,6 +37850,7 @@ export {
   statusPolicies,
   projectGraphDirections,
   projectCopyFlags,
+  otherwiseChoices,
   commandResponseRoots,
   commandAlternateRoots,
   clientCommands,