@onetaskgraph/sdk 0.12.12 → 0.12.14

package/dist/index.js

@@ -7167,6 +7167,7 @@ var binaryCommands = [
   "task render",
   "task answers",
   "task assets",
+  "task project-human",
   "project list",
   "project show",
   "project deps",
@@ -7192,7 +7193,7 @@ var binaryCommands = [
 ];
 
 // src/generated/models.ts
-var SCHEMA_BUNDLE_VERSION = 49;
+var SCHEMA_BUNDLE_VERSION = 51;
 
 // src/generated/schemas.ts
 var runtimeSchemas = {
@@ -8325,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.
 
@@ -8333,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.
 
@@ -8361,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: {
@@ -8458,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"
       }
     },
@@ -8521,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: [
           {
@@ -9428,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"
           }
         ]
       },
@@ -9896,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"
           }
         ]
       },
@@ -10000,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-]*$",
@@ -10033,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",
@@ -10130,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"
       }
     },
@@ -10382,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: [
           {
@@ -10399,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: [
           {
@@ -10408,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",
@@ -10426,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: [
@@ -10767,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: [
               {
@@ -10784,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: [
               {
@@ -10793,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",
@@ -10811,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: [
@@ -10851,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"
           }
         ]
       },
@@ -11072,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-]*$",
@@ -11105,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: [
@@ -11150,16 +11631,34 @@ interprets none of them, which is why the budget and unit names are open vocabul
           }
         ]
       },
-      WriteFallback: {
-        description: "That an expected write read its target before writing, and why.",
+      StatusCondition: {
+        description: "What a guarded copy found a counterpart's status at, and whether that met the condition.",
         properties: {
-          read: {
-            description: "Always `true`: the write made one read.",
-            type: "boolean"
+          held: {
+            $ref: "#/$defs/StatusCategory",
+            description: "The counterpart's status category, as the copy's own pre-write read held it."
           },
-          reason: {
-            description: "Why it could not take what it needed from the cache.",
-            type: "string"
+          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: [
@@ -11247,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"
       }
     },
@@ -11402,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.",
@@ -11463,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.
 
@@ -11491,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: {
@@ -11588,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"
       }
     },
@@ -13684,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.
 
@@ -13712,21 +14443,87 @@ 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"
+      },
+      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: {
+          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"
       },
@@ -13809,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"
       }
     },
@@ -13856,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: [
@@ -14059,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-]*$",
@@ -14092,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: {
@@ -14189,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"
       }
     },
@@ -14231,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: [
           {
@@ -14240,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: [
@@ -14701,27 +15677,241 @@ and a whole item is not what a landing's closure needs.`,
         default: "task",
         description: "Which kind of item it is. Defaulted to `task` and left out of the wire while it is one,\nso a plugin written before a project could be held answers exactly what it answered."
       },
-      option: {
+      option: {
+        default: null,
+        description: `The name of the option the task's card sits at, as the source spells it, when it sits
+at one.`,
+        type: [
+          "string",
+          "null"
+        ]
+      },
+      repositories: {
+        description: "The repositories the task names.",
+        items: {
+          $ref: "#/$defs/Repository"
+        },
+        type: "array"
+      }
+    },
+    required: [
+      "id"
+    ],
+    title: "HeldTask",
+    type: "object"
+  },
+  HumanTaskProjected: {
+    $defs: {
+      SourceName: {
+        description: "The name a configuration document gives one configured source.",
+        pattern: "^[a-z0-9][a-z0-9-]*$",
+        type: "string"
+      }
+    },
+    $schema: "https://json-schema.org/draft/2020-12/schema",
+    additionalProperties: false,
+    description: "A durable projection's bound tracker identity, suitable for a directly clickable card.",
+    properties: {
+      project: {
+        description: "The resolved destination project.",
+        type: "string"
+      },
+      source: {
+        $ref: "#/$defs/SourceName",
+        description: "The resolved configured source."
+      },
+      task: {
+        description: "The qualified task identity.",
+        type: "string"
+      },
+      url: {
+        description: "The canonical tracker issue URL.",
+        type: "string"
+      }
+    },
+    required: [
+      "task",
+      "url",
+      "project",
+      "source"
+    ],
+    title: "HumanTaskProjected",
+    type: "object"
+  },
+  HumanTaskProjection: {
+    $defs: {
+      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"
+          }
+        ]
+      },
+      ProjectionOwner: {
+        additionalProperties: false,
+        description: "The producer that owns the intent; nullable run and plan are explicit on the wire.",
+        properties: {
+          plan: {
+            description: "The owning plan, when applicable.",
+            type: [
+              "string",
+              "null"
+            ]
+          },
+          run: {
+            description: "The owning run, when applicable.",
+            type: [
+              "string",
+              "null"
+            ]
+          },
+          session: {
+            description: "The owning session.",
+            type: "string"
+          }
+        },
+        required: [
+          "session",
+          "run",
+          "plan"
+        ],
+        type: "object"
+      },
+      ProjectionState: {
+        description: "The requested tracker lifecycle. Questions have no representation here.",
+        oneOf: [
+          {
+            const: "open",
+            description: "The operator has work to do.",
+            type: "string"
+          },
+          {
+            const: "completed",
+            description: "The operator completed the work.",
+            type: "string"
+          },
+          {
+            const: "dismissed",
+            description: "The operator dismissed the work, optionally recording a reason.",
+            type: "string"
+          }
+        ]
+      },
+      ProjectionVersion: {
+        const: 1,
+        type: "integer"
+      },
+      Repository: {
+        description: "A repository identified by its normalized origin, without a URL scheme or `.git` suffix.",
+        type: "string"
+      },
+      SourceName: {
+        description: "The name a configuration document gives one configured source.",
+        pattern: "^[a-z0-9][a-z0-9-]*$",
+        type: "string"
+      }
+    },
+    $schema: "https://json-schema.org/draft/2020-12/schema",
+    additionalProperties: false,
+    description: "Version 1 of the general human task projection request.",
+    properties: {
+      body: {
+        description: "The visible task content.",
+        type: "string"
+      },
+      item_id: {
+        description: "The external idempotency identity, stable across producer retries.",
+        type: "string"
+      },
+      owner: {
+        $ref: "#/$defs/ProjectionOwner",
+        description: "The producer that owns the intent."
+      },
+      priority: {
+        $ref: "#/$defs/Priority",
+        description: "Its priority, using the existing plugin API serialization."
+      },
+      project: {
+        description: "The plan's resolved destination project, or null for a configured human project.",
+        type: [
+          "string",
+          "null"
+        ]
+      },
+      reason: {
         default: null,
-        description: `The name of the option the task's card sits at, as the source spells it, when it sits
-at one.`,
+        description: "An optional dismissal reason. Omission and null both preserve absence.",
         type: [
           "string",
           "null"
         ]
       },
       repositories: {
-        description: "The repositories the task names.",
+        description: "Normalized repository origins whose work this item concerns.",
         items: {
           $ref: "#/$defs/Repository"
         },
         type: "array"
+      },
+      schema_version: {
+        $ref: "#/$defs/ProjectionVersion",
+        description: "The wire contract version, always 1."
+      },
+      source: {
+        $ref: "#/$defs/SourceName",
+        description: "The configured source through which placement is resolved."
+      },
+      state: {
+        $ref: "#/$defs/ProjectionState",
+        description: "The desired lifecycle."
+      },
+      title: {
+        description: "The visible task title.",
+        type: "string"
       }
     },
     required: [
-      "id"
+      "schema_version",
+      "item_id",
+      "owner",
+      "title",
+      "body",
+      "priority",
+      "repositories",
+      "project",
+      "source",
+      "state"
     ],
-    title: "HeldTask",
+    title: "HumanTaskProjection",
     type: "object"
   },
   IssueCompleted: {
@@ -16122,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`."
@@ -16405,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.
 
@@ -16433,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: {
@@ -16530,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"
       }
     },
@@ -29598,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.
 
@@ -29613,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.",
@@ -29723,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"
       }
     },
@@ -32150,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: {
@@ -32247,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"
       }
     },
@@ -32856,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-]*$",
@@ -33052,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"
       }
     },
@@ -34655,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"
       }
     },
@@ -35241,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;
@@ -35312,6 +36976,7 @@ var commandResponseRoots = {
   "task render": "Regenerated",
   "task answers": "TemplateAnswers",
   "task assets": "TaskAssetNames",
+  "task project-human": "HumanTaskProjected",
   "document create": "DocumentDetail",
   "document render": "Regenerated",
   "document answers": "TemplateAnswers"
@@ -35319,7 +36984,7 @@ var commandResponseRoots = {
 var commandAlternateRoots = {
   "sources fields": ["StatusNamesReport"]
 };
-var partialResponseCommands = new Set(Object.keys(commandResponseRoots).filter((command) => command !== "config show" && command !== "cache clear" && command !== "sources list" && command !== "sources fields" && command !== "sources route" && command !== "project graph" && !command.startsWith("task comment ") && !command.endsWith(" metadata set") && !command.endsWith(" priority set") && !command.endsWith(" content set") && !command.startsWith("template ") && !command.endsWith(" render") && !command.endsWith(" answers") && command !== "task assets" && command !== "project create" && command !== "document create"));
+var partialResponseCommands = new Set(Object.keys(commandResponseRoots).filter((command) => command !== "config show" && command !== "cache clear" && command !== "sources list" && command !== "sources fields" && command !== "sources route" && command !== "project graph" && !command.startsWith("task comment ") && !command.endsWith(" metadata set") && !command.endsWith(" priority set") && !command.endsWith(" content set") && !command.startsWith("template ") && !command.endsWith(" render") && !command.endsWith(" answers") && command !== "task assets" && command !== "task project-human" && command !== "project create" && command !== "document create"));
 function bodyArguments(options) {
   return "bodyFile" in options ? { args: ["--body-file", options.bodyFile] } : { args: [], input: options.body };
 }
@@ -35668,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)
@@ -36066,6 +37745,12 @@ class OnetaskgraphClient {
   taskAssets(id, outputDir) {
     return this.run("task assets", [id, "--output-dir", outputDir]);
   }
+  taskProjectHuman(input) {
+    return this.run("task project-human", [
+      "--input",
+      stringOption("taskProjectHuman", "input", input)
+    ]);
+  }
   async projectCreate(source, id, title, options = {}) {
     const { args, input } = createArguments("projectCreate", ["--id", id, "--title", title], options);
     if (options.status !== undefined)
@@ -36157,7 +37842,7 @@ function assertCompleteCommandSurface() {
 }
 
 // src/index.ts
-var VERSION = "0.12.12";
+var VERSION = "0.12.14";
 export {
   taskUpdateOptionFlags,
   taskUpdateFlags,
@@ -36165,6 +37850,7 @@ export {
   statusPolicies,
   projectGraphDirections,
   projectCopyFlags,
+  otherwiseChoices,
   commandResponseRoots,
   commandAlternateRoots,
   clientCommands,