@onetaskgraph/sdk 0.12.12 → 0.12.14

package/dist/generated/models.d.ts

@@ -1,4 +1,4 @@
-export declare const SCHEMA_BUNDLE_VERSION: 49;
+export declare const SCHEMA_BUNDLE_VERSION: 51;
 export declare namespace GeneratedAsset {
     /**
      * One asset a record holds, as a read reports it.
@@ -668,6 +668,13 @@ export declare namespace GeneratedCommentList {
 }
 export type CommentList = GeneratedCommentList.CommentList;
 export declare namespace GeneratedCommentWritten {
+    /**
+     * 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 GlobalId = string;
     /**
      * One mutation of an expected write.
      */
@@ -708,6 +715,16 @@ export declare namespace GeneratedCommentWritten {
         outcome: "unknown";
         [k: string]: any;
     });
+    /**
+     * 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.
+     */
+    type Priority = ("none" | "urgent" | "high" | "medium" | "low");
     /**
      * What `task comment add` and `task comment edit` answer with: the comment as its source now
      * holds it — its id and its address among it, so a caller never needs a lookup for either —
@@ -738,6 +755,11 @@ export declare namespace GeneratedCommentWritten {
          * the qualified id of the task it is on, so its own id needs no source of its own.
          */
         id: string;
+        /**
+         * The qualified id of the task the comment was added to — present on `task comment add`'s
+         * answer, so a caller records what it commented on from the answer alone.
+         */
+        item?: (GlobalId | null);
         /**
          * The comment this one is a copy of, at its origin — present only on a comment a copy
          * wrote, and absent on every comment a person wrote where it is.
@@ -812,19 +834,54 @@ export declare namespace GeneratedCommentWritten {
         [k: string]: any;
     }
     /**
-     * What each mutation of an expected write came to, built from the mutations' own responses.
+     * 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.
      */
     interface WriteResult {
         /**
-         * One per mutation sent, in the order sent.
+         * One per mutation an expected write sent, in the order sent — absent for a write made
+         * without `--expect`.
+         */
+        parts?: (WritePart[] | null);
+        /**
+         * A task's priority after the write — `null` for a project or a document, which carry
+         * none, and where an expected write that failed cannot say.
          */
-        parts: WritePart[];
+        priority?: (Priority | null);
+        /**
+         * The item's status after the write, exactly as `task show` spells it — `null` for a
+         * document, which has none, and where an expected write that failed cannot say.
+         */
+        status?: (Status | null);
         /**
-         * The task's version after the write, where the last response determines it.
+         * The item's version after the write, where the write's responses determine it.
          */
         version?: (string | null);
         [k: string]: any;
     }
+    /**
+     * 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".
+     */
+    interface Status {
+        /**
+         * The normalised value filters compare against.
+         */
+        category: ("draft" | "backlog" | "todo" | "queued" | "in-progress" | "done" | "cancelled" | "unknown");
+        /**
+         * The source's own label for this status.
+         */
+        name: string;
+        [k: string]: any;
+    }
     /**
      * What one command spent, summed over the sources in it that meter their own requests.
      *
@@ -1384,7 +1441,7 @@ export declare namespace GeneratedCopyAction {
         /**
          * Which rule found it.
          */
-        via: ("target-task" | "link" | "origin" | "scan" | "match");
+        via: ("target-task" | "link" | "origin" | "scan" | "match" | "intent");
         [k: string]: any;
     } | {
         action: "unchanged";
@@ -1415,7 +1472,7 @@ export declare namespace GeneratedCopyAction {
         /**
          * Which rule found it.
          */
-        via: ("target-task" | "link" | "origin" | "scan" | "match");
+        via: ("target-task" | "link" | "origin" | "scan" | "match" | "intent");
         [k: string]: any;
     } | {
         action: "orphaned";
@@ -1538,6 +1595,11 @@ export declare namespace GeneratedCopyOutcome {
          * mutations.
          */
         fallback?: (WriteFallback | null);
+        /**
+         * What the counterpart held, as the copy's read of it before writing found it — present
+         * only on an item the copy refused after that read, such as `destination-status`.
+         */
+        held?: (WriteResult | null);
         /**
          * Which source a routed copy placed it in, and the index of the route entry that
          * matched — `null` there when none did.
@@ -1549,8 +1611,16 @@ export declare namespace GeneratedCopyOutcome {
          */
         placed?: (Placement | null);
         /**
-         * What each mutation the write sent came to, and the version it left the task at — for a
-         * source that reports its writes' parts.
+         * What `--when-destination-priority` found the counterpart's priority at, and whether
+         * that met it — present only when the copy was given the condition and this item was an
+         * update of a task.
+         */
+        priority_condition?: (PriorityCondition | null);
+        /**
+         * 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.
          */
         result?: (WriteResult | null);
         /**
@@ -1565,6 +1635,12 @@ export declare namespace GeneratedCopyOutcome {
          * read included.
          */
         spent?: (Spent | null);
+        /**
+         * What `--when-destination-status` found the counterpart's status at, and whether that
+         * met it — present only when the copy was given the condition and this item was an update
+         * of a task, a refused one included.
+         */
+        status_condition?: (StatusCondition | null);
         [k: string]: any;
     } & ({
         action: "created";
@@ -1612,7 +1688,7 @@ export declare namespace GeneratedCopyOutcome {
         /**
          * Which rule found it.
          */
-        via: ("target-task" | "link" | "origin" | "scan" | "match");
+        via: ("target-task" | "link" | "origin" | "scan" | "match" | "intent");
         [k: string]: any;
     } | {
         action: "unchanged";
@@ -1643,7 +1719,7 @@ export declare namespace GeneratedCopyOutcome {
         /**
          * Which rule found it.
          */
-        via: ("target-task" | "link" | "origin" | "scan" | "match");
+        via: ("target-task" | "link" | "origin" | "scan" | "match" | "intent");
         [k: string]: any;
     } | {
         action: "orphaned";
@@ -1707,6 +1783,16 @@ export declare namespace GeneratedCopyOutcome {
         outcome: "unknown";
         [k: string]: any;
     });
+    /**
+     * 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.
+     */
+    type Priority = ("none" | "urgent" | "high" | "medium" | "low");
     /**
      * One item, qualified by the source it came from.
      *
@@ -1737,6 +1823,55 @@ export declare namespace GeneratedCopyOutcome {
         reason: string;
         [k: string]: any;
     }
+    /**
+     * 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.
+     */
+    interface WriteResult {
+        /**
+         * One per mutation an expected write sent, in the order sent — absent for a write made
+         * without `--expect`.
+         */
+        parts?: (WritePart[] | null);
+        /**
+         * A task's priority after the write — `null` for a project or a document, which carry
+         * none, and where an expected write that failed cannot say.
+         */
+        priority?: (Priority | null);
+        /**
+         * The item's status after the write, exactly as `task show` spells it — `null` for a
+         * document, which has none, and where an expected write that failed cannot say.
+         */
+        status?: (Status | null);
+        /**
+         * The item's version after the write, where the write's responses determine it.
+         */
+        version?: (string | null);
+        [k: string]: any;
+    }
+    /**
+     * 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".
+     */
+    interface Status {
+        /**
+         * The normalised value filters compare against.
+         */
+        category: ("draft" | "backlog" | "todo" | "queued" | "in-progress" | "done" | "cancelled" | "unknown");
+        /**
+         * The source's own label for this status.
+         */
+        name: string;
+        [k: string]: any;
+    }
     /**
      * Where one item written to a source lands, and which of its routes put it there.
      *
@@ -1756,17 +1891,17 @@ export declare namespace GeneratedCopyOutcome {
         [k: string]: any;
     }
     /**
-     * What each mutation of an expected write came to, built from the mutations' own responses.
+     * What a guarded copy found a counterpart's priority at, and whether that met the condition.
      */
-    interface WriteResult {
+    interface PriorityCondition {
         /**
-         * One per mutation sent, in the order sent.
+         * The counterpart's priority, as the copy's own pre-write read held it.
          */
-        parts: WritePart[];
+        held: ("none" | "urgent" | "high" | "medium" | "low");
         /**
-         * The task's version after the write, where the last response determines it.
+         * Whether that priority is one the condition names.
          */
-        version?: (string | null);
+        met: boolean;
         [k: string]: any;
     }
     /**
@@ -1812,6 +1947,20 @@ export declare namespace GeneratedCopyOutcome {
         unit: string;
         [k: string]: any;
     }
+    /**
+     * What a guarded copy found a counterpart's status at, and whether that met the condition.
+     */
+    interface StatusCondition {
+        /**
+         * The counterpart's status category, as the copy's own pre-write read held it.
+         */
+        held: ("draft" | "backlog" | "todo" | "queued" | "in-progress" | "done" | "cancelled" | "unknown");
+        /**
+         * Whether that category is one the condition names.
+         */
+        met: boolean;
+        [k: string]: any;
+    }
     /**
      * What a `--comments` copy did to one task's comments at the destination.
      *
@@ -1961,6 +2110,11 @@ export declare namespace GeneratedCopyReport {
          * mutations.
          */
         fallback?: (WriteFallback | null);
+        /**
+         * What the counterpart held, as the copy's read of it before writing found it — present
+         * only on an item the copy refused after that read, such as `destination-status`.
+         */
+        held?: (WriteResult | null);
         /**
          * Which source a routed copy placed it in, and the index of the route entry that
          * matched — `null` there when none did.
@@ -1972,8 +2126,16 @@ export declare namespace GeneratedCopyReport {
          */
         placed?: (Placement | null);
         /**
-         * What each mutation the write sent came to, and the version it left the task at — for a
-         * source that reports its writes' parts.
+         * What `--when-destination-priority` found the counterpart's priority at, and whether
+         * that met it — present only when the copy was given the condition and this item was an
+         * update of a task.
+         */
+        priority_condition?: (PriorityCondition | null);
+        /**
+         * 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.
          */
         result?: (WriteResult | null);
         /**
@@ -1988,6 +2150,12 @@ export declare namespace GeneratedCopyReport {
          * read included.
          */
         spent?: (Spent | null);
+        /**
+         * What `--when-destination-status` found the counterpart's status at, and whether that
+         * met it — present only when the copy was given the condition and this item was an update
+         * of a task, a refused one included.
+         */
+        status_condition?: (StatusCondition | null);
         [k: string]: any;
     } & CopyOutcome1);
     /**
@@ -2030,6 +2198,16 @@ export declare namespace GeneratedCopyReport {
         outcome: "unknown";
         [k: string]: any;
     });
+    /**
+     * 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.
+     */
+    type Priority = ("none" | "urgent" | "high" | "medium" | "low");
     type CopyOutcome1 = ({
         action: "created";
         /**
@@ -2076,7 +2254,7 @@ export declare namespace GeneratedCopyReport {
         /**
          * Which rule found it.
          */
-        via: ("target-task" | "link" | "origin" | "scan" | "match");
+        via: ("target-task" | "link" | "origin" | "scan" | "match" | "intent");
         [k: string]: any;
     } | {
         action: "unchanged";
@@ -2107,7 +2285,7 @@ export declare namespace GeneratedCopyReport {
         /**
          * Which rule found it.
          */
-        via: ("target-task" | "link" | "origin" | "scan" | "match");
+        via: ("target-task" | "link" | "origin" | "scan" | "match" | "intent");
         [k: string]: any;
     } | {
         action: "orphaned";
@@ -2250,6 +2428,55 @@ export declare namespace GeneratedCopyReport {
         reason: string;
         [k: string]: any;
     }
+    /**
+     * 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.
+     */
+    interface WriteResult {
+        /**
+         * One per mutation an expected write sent, in the order sent — absent for a write made
+         * without `--expect`.
+         */
+        parts?: (WritePart[] | null);
+        /**
+         * A task's priority after the write — `null` for a project or a document, which carry
+         * none, and where an expected write that failed cannot say.
+         */
+        priority?: (Priority | null);
+        /**
+         * The item's status after the write, exactly as `task show` spells it — `null` for a
+         * document, which has none, and where an expected write that failed cannot say.
+         */
+        status?: (Status | null);
+        /**
+         * The item's version after the write, where the write's responses determine it.
+         */
+        version?: (string | null);
+        [k: string]: any;
+    }
+    /**
+     * 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".
+     */
+    interface Status {
+        /**
+         * The normalised value filters compare against.
+         */
+        category: ("draft" | "backlog" | "todo" | "queued" | "in-progress" | "done" | "cancelled" | "unknown");
+        /**
+         * The source's own label for this status.
+         */
+        name: string;
+        [k: string]: any;
+    }
     /**
      * Where one item written to a source lands, and which of its routes put it there.
      *
@@ -2269,17 +2496,23 @@ export declare namespace GeneratedCopyReport {
         [k: string]: any;
     }
     /**
-     * What each mutation of an expected write came to, built from the mutations' own responses.
+     * What a guarded copy found a counterpart's priority at, and whether that met the condition.
      */
-    interface WriteResult {
+    interface PriorityCondition {
         /**
-         * One per mutation sent, in the order sent.
+         * 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.
          */
-        parts: WritePart[];
+        held: ("none" | "urgent" | "high" | "medium" | "low");
         /**
-         * The task's version after the write, where the last response determines it.
+         * Whether that priority is one the condition names.
          */
-        version?: (string | null);
+        met: boolean;
         [k: string]: any;
     }
     /**
@@ -2325,6 +2558,20 @@ export declare namespace GeneratedCopyReport {
         unit: string;
         [k: string]: any;
     }
+    /**
+     * What a guarded copy found a counterpart's status at, and whether that met the condition.
+     */
+    interface StatusCondition {
+        /**
+         * The counterpart's status category, as the copy's own pre-write read held it.
+         */
+        held: ("draft" | "backlog" | "todo" | "queued" | "in-progress" | "done" | "cancelled" | "unknown");
+        /**
+         * Whether that category is one the condition names.
+         */
+        met: boolean;
+        [k: string]: any;
+    }
     /**
      * What a `--comments` copy did to one task's comments at the destination.
      *
@@ -2394,9 +2641,36 @@ export declare namespace GeneratedCopyVia {
      * recording it as its origin, and the caller's `--match-by`. When none answers, the item is created and says
      * so as [`NoCounterpart`] instead.
      */
-    type CopyVia = ("target-task" | "link" | "origin" | "scan" | "match");
+    type CopyVia = ("target-task" | "link" | "origin" | "scan" | "match" | "intent");
 }
 export type CopyVia = GeneratedCopyVia.CopyVia;
+export declare namespace GeneratedCreateSettings {
+    /**
+     * How a copy out of one source keeps a create safe to retry: its two settings, each in whole
+     * seconds, read off the source's own block beside `cache` and `routes`.
+     *
+     * `create_lease_seconds` is how long the intent a copy records on the item it copies, at
+     * `onetaskgraph.creating`, stays its own before another attempt may take it over — read off
+     * the copy's **source**. `create_quiescence_seconds` is how long after an intent was first
+     * taken a retry waits for an earlier attempt's create to become listed before creating again
+     * — read off the copy's **destination**, and only where that destination's lookup by create
+     * key can lag a create. Both default to 120 and are left out of a configuration that does not
+     * set them.
+     */
+    interface CreateSettings {
+        /**
+         * Seconds an intent to create stays the holder's own; 120 when absent.
+         */
+        create_lease_seconds?: (number | null);
+        /**
+         * Seconds after an intent was first taken that a retry waits for the earlier create to be
+         * listed; 120 when absent.
+         */
+        create_quiescence_seconds?: (number | null);
+        [k: string]: any;
+    }
+}
+export type CreateSettings = GeneratedCreateSettings.CreateSettings;
 export declare namespace GeneratedCredentialLayer {
     /**
      * Which layer answered for one credential name.
@@ -2445,6 +2719,16 @@ export declare namespace GeneratedDeletedComment {
         outcome: "unknown";
         [k: string]: any;
     });
+    /**
+     * 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.
+     */
+    type Priority = ("none" | "urgent" | "high" | "medium" | "low");
     /**
      * What `task comment delete` answers with: the id of the comment it removed.
      */
@@ -2485,19 +2769,54 @@ export declare namespace GeneratedDeletedComment {
         [k: string]: any;
     }
     /**
-     * What each mutation of an expected write came to, built from the mutations' own responses.
+     * 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.
      */
     interface WriteResult {
         /**
-         * One per mutation sent, in the order sent.
+         * One per mutation an expected write sent, in the order sent — absent for a write made
+         * without `--expect`.
+         */
+        parts?: (WritePart[] | null);
+        /**
+         * A task's priority after the write — `null` for a project or a document, which carry
+         * none, and where an expected write that failed cannot say.
          */
-        parts: WritePart[];
+        priority?: (Priority | null);
+        /**
+         * The item's status after the write, exactly as `task show` spells it — `null` for a
+         * document, which has none, and where an expected write that failed cannot say.
+         */
+        status?: (Status | null);
         /**
-         * The task's version after the write, where the last response determines it.
+         * The item's version after the write, where the write's responses determine it.
          */
         version?: (string | null);
         [k: string]: any;
     }
+    /**
+     * 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".
+     */
+    interface Status {
+        /**
+         * The normalised value filters compare against.
+         */
+        category: ("draft" | "backlog" | "todo" | "queued" | "in-progress" | "done" | "cancelled" | "unknown");
+        /**
+         * The source's own label for this status.
+         */
+        name: string;
+        [k: string]: any;
+    }
     /**
      * What one command spent, summed over the sources in it that meter their own requests.
      *
@@ -3584,6 +3903,16 @@ export declare namespace GeneratedExpectedWrite {
         outcome: "unknown";
         [k: string]: any;
     });
+    /**
+     * 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.
+     */
+    type Priority = ("none" | "urgent" | "high" | "medium" | "low");
     /**
      * What a write that expected a version of its task came to: the `result`, `fallback` and
      * `spent` members of its JSON.
@@ -3595,8 +3924,10 @@ export declare namespace GeneratedExpectedWrite {
          */
         fallback?: (WriteFallback | null);
         /**
-         * What each mutation the write sent came to, and the version it left the task at — for a
-         * source that reports its writes' parts.
+         * 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.
          */
         result?: (WriteResult | null);
         /**
@@ -3621,19 +3952,54 @@ export declare namespace GeneratedExpectedWrite {
         [k: string]: any;
     }
     /**
-     * What each mutation of an expected write came to, built from the mutations' own responses.
+     * 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.
      */
     interface WriteResult {
         /**
-         * One per mutation sent, in the order sent.
+         * One per mutation an expected write sent, in the order sent — absent for a write made
+         * without `--expect`.
+         */
+        parts?: (WritePart[] | null);
+        /**
+         * A task's priority after the write — `null` for a project or a document, which carry
+         * none, and where an expected write that failed cannot say.
          */
-        parts: WritePart[];
+        priority?: (Priority | null);
+        /**
+         * The item's status after the write, exactly as `task show` spells it — `null` for a
+         * document, which has none, and where an expected write that failed cannot say.
+         */
+        status?: (Status | null);
         /**
-         * The task's version after the write, where the last response determines it.
+         * The item's version after the write, where the write's responses determine it.
          */
         version?: (string | null);
         [k: string]: any;
     }
+    /**
+     * 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".
+     */
+    interface Status {
+        /**
+         * The normalised value filters compare against.
+         */
+        category: ("draft" | "backlog" | "todo" | "queued" | "in-progress" | "done" | "cancelled" | "unknown");
+        /**
+         * The source's own label for this status.
+         */
+        name: string;
+        [k: string]: any;
+    }
     /**
      * What one command spent, summed over the sources in it that meter their own requests.
      *
@@ -3773,6 +4139,16 @@ export declare namespace GeneratedFailureDocument {
         outcome: "unknown";
         [k: string]: any;
     });
+    /**
+     * 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.
+     */
+    type Priority = ("none" | "urgent" | "high" | "medium" | "low");
     /**
      * The document a command writes to standard output when it exits `1` under machine
      * output: one object whose single member is the [`Failure`].
@@ -3788,8 +4164,16 @@ export declare namespace GeneratedFailureDocument {
          */
         fallback?: (WriteFallback | null);
         /**
-         * What each mutation the write sent came to, and the version it left the task at — for a
-         * source that reports its writes' parts.
+         * What the destination item a copy refused to write held, as the copy's read of it
+         * before writing found it — present only for a refusal made after that read, such as
+         * `target-task-origin`.
+         */
+        held?: (WriteResult | null);
+        /**
+         * 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.
          */
         result?: (WriteResult | null);
         /**
@@ -3842,17 +4226,52 @@ export declare namespace GeneratedFailureDocument {
         [k: string]: any;
     }
     /**
-     * What each mutation of an expected write came to, built from the mutations' own responses.
+     * 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.
+     */
+    interface WriteResult {
+        /**
+         * One per mutation an expected write sent, in the order sent — absent for a write made
+         * without `--expect`.
+         */
+        parts?: (WritePart[] | null);
+        /**
+         * A task's priority after the write — `null` for a project or a document, which carry
+         * none, and where an expected write that failed cannot say.
+         */
+        priority?: (Priority | null);
+        /**
+         * The item's status after the write, exactly as `task show` spells it — `null` for a
+         * document, which has none, and where an expected write that failed cannot say.
+         */
+        status?: (Status | null);
+        /**
+         * The item's version after the write, where the write's responses determine it.
+         */
+        version?: (string | null);
+        [k: string]: any;
+    }
+    /**
+     * 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".
      */
-    interface WriteResult {
+    interface Status {
         /**
-         * One per mutation sent, in the order sent.
+         * The normalised value filters compare against.
          */
-        parts: WritePart[];
+        category: ("draft" | "backlog" | "todo" | "queued" | "in-progress" | "done" | "cancelled" | "unknown");
         /**
-         * The task's version after the write, where the last response determines it.
+         * The source's own label for this status.
          */
-        version?: (string | null);
+        name: string;
         [k: string]: any;
     }
     /**
@@ -4135,6 +4554,100 @@ export declare namespace GeneratedHeldTask {
     }
 }
 export type HeldTask = GeneratedHeldTask.HeldTask;
+export declare namespace GeneratedHumanTaskProjected {
+    /**
+     * A durable projection's bound tracker identity, suitable for a directly clickable card.
+     */
+    interface HumanTaskProjected {
+        /**
+         * The resolved destination project.
+         */
+        project: string;
+        /**
+         * The resolved configured source.
+         */
+        source: string;
+        /**
+         * The qualified task identity.
+         */
+        task: string;
+        /**
+         * The canonical tracker issue URL.
+         */
+        url: string;
+    }
+}
+export type HumanTaskProjected = GeneratedHumanTaskProjected.HumanTaskProjected;
+export declare namespace GeneratedHumanTaskProjection {
+    /**
+     * A repository identified by its normalized origin, without a URL scheme or `.git` suffix.
+     */
+    type Repository = string;
+    /**
+     * Version 1 of the general human task projection request.
+     */
+    interface HumanTaskProjection {
+        /**
+         * The visible task content.
+         */
+        body: string;
+        /**
+         * The external idempotency identity, stable across producer retries.
+         */
+        item_id: string;
+        owner: ProjectionOwner;
+        /**
+         * Its priority, using the existing plugin API serialization.
+         */
+        priority: ("none" | "urgent" | "high" | "medium" | "low");
+        /**
+         * The plan's resolved destination project, or null for a configured human project.
+         */
+        project: (string | null);
+        /**
+         * An optional dismissal reason. Omission and null both preserve absence.
+         */
+        reason?: (string | null);
+        /**
+         * Normalized repository origins whose work this item concerns.
+         */
+        repositories: Repository[];
+        /**
+         * The wire contract version, always 1.
+         */
+        schema_version: 1;
+        /**
+         * The configured source through which placement is resolved.
+         */
+        source: string;
+        /**
+         * The desired lifecycle.
+         */
+        state: ("open" | "completed" | "dismissed");
+        /**
+         * The visible task title.
+         */
+        title: string;
+    }
+    /**
+     * The producer that owns the intent.
+     */
+    interface ProjectionOwner {
+        /**
+         * The owning plan, when applicable.
+         */
+        plan: (string | null);
+        /**
+         * The owning run, when applicable.
+         */
+        run: (string | null);
+        /**
+         * The owning session.
+         */
+        session: string;
+    }
+}
+export type HumanTaskProjection = GeneratedHumanTaskProjection.HumanTaskProjection;
 export declare namespace GeneratedIssueCompleted {
     /**
      * What keeping one delivered task in step with one deliverer came to.
@@ -4914,13 +5427,19 @@ export declare namespace GeneratedLocateReport {
         /**
          * Which rule found it, as a copy's report spells it.
          */
-        via: ("target-task" | "link" | "origin" | "scan" | "match");
+        via: ("target-task" | "link" | "origin" | "scan" | "match" | "intent");
         [k: string]: any;
     }
     /**
      * Where a create would file a task's issue.
      */
     interface CreatesIn {
+        /**
+         * Why the destination's own policy on where it creates — a GitHub Projects source's
+         * `creation_owners` — would refuse a create there, as the copy's refusal says it; absent
+         * when it would not. The locate itself never fails for it.
+         */
+        refused?: (string | null);
         /**
          * The repository, as a normalized origin `host/owner/name`.
          */
@@ -5058,6 +5577,16 @@ export declare namespace GeneratedMetadataSet {
         outcome: "unknown";
         [k: string]: any;
     });
+    /**
+     * 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.
+     */
+    type Priority = ("none" | "urgent" | "high" | "medium" | "low");
     /**
      * What `task`, `project` and `document metadata set` answer with.
      */
@@ -5111,19 +5640,54 @@ export declare namespace GeneratedMetadataSet {
         [k: string]: any;
     }
     /**
-     * What each mutation of an expected write came to, built from the mutations' own responses.
+     * 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.
      */
     interface WriteResult {
         /**
-         * One per mutation sent, in the order sent.
+         * One per mutation an expected write sent, in the order sent — absent for a write made
+         * without `--expect`.
+         */
+        parts?: (WritePart[] | null);
+        /**
+         * A task's priority after the write — `null` for a project or a document, which carry
+         * none, and where an expected write that failed cannot say.
+         */
+        priority?: (Priority | null);
+        /**
+         * The item's status after the write, exactly as `task show` spells it — `null` for a
+         * document, which has none, and where an expected write that failed cannot say.
          */
-        parts: WritePart[];
+        status?: (Status | null);
         /**
-         * The task's version after the write, where the last response determines it.
+         * The item's version after the write, where the write's responses determine it.
          */
         version?: (string | null);
         [k: string]: any;
     }
+    /**
+     * 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".
+     */
+    interface Status {
+        /**
+         * The normalised value filters compare against.
+         */
+        category: ("draft" | "backlog" | "todo" | "queued" | "in-progress" | "done" | "cancelled" | "unknown");
+        /**
+         * The source's own label for this status.
+         */
+        name: string;
+        [k: string]: any;
+    }
     /**
      * What one command spent, summed over the sources in it that meter their own requests.
      *
@@ -11512,6 +12076,16 @@ export declare namespace GeneratedTaskContentSet {
         outcome: "unknown";
         [k: string]: any;
     });
+    /**
+     * 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.
+     */
+    type Priority = ("none" | "urgent" | "high" | "medium" | "low");
     /**
      * What `task content set` answers with.
      */
@@ -11559,19 +12133,54 @@ export declare namespace GeneratedTaskContentSet {
         [k: string]: any;
     }
     /**
-     * What each mutation of an expected write came to, built from the mutations' own responses.
+     * 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.
      */
     interface WriteResult {
         /**
-         * One per mutation sent, in the order sent.
+         * One per mutation an expected write sent, in the order sent — absent for a write made
+         * without `--expect`.
+         */
+        parts?: (WritePart[] | null);
+        /**
+         * A task's priority after the write — `null` for a project or a document, which carry
+         * none, and where an expected write that failed cannot say.
+         */
+        priority?: (Priority | null);
+        /**
+         * The item's status after the write, exactly as `task show` spells it — `null` for a
+         * document, which has none, and where an expected write that failed cannot say.
          */
-        parts: WritePart[];
+        status?: (Status | null);
         /**
-         * The task's version after the write, where the last response determines it.
+         * The item's version after the write, where the write's responses determine it.
          */
         version?: (string | null);
         [k: string]: any;
     }
+    /**
+     * 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".
+     */
+    interface Status {
+        /**
+         * The normalised value filters compare against.
+         */
+        category: ("draft" | "backlog" | "todo" | "queued" | "in-progress" | "done" | "cancelled" | "unknown");
+        /**
+         * The source's own label for this status.
+         */
+        name: string;
+        [k: string]: any;
+    }
     /**
      * What one command spent, summed over the sources in it that meter their own requests.
      *
@@ -12983,6 +13592,16 @@ export declare namespace GeneratedTaskPrioritySet {
         outcome: "unknown";
         [k: string]: any;
     });
+    /**
+     * 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.
+     */
+    type Priority = ("none" | "urgent" | "high" | "medium" | "low");
     /**
      * What `task priority set` answers with.
      */
@@ -12997,7 +13616,13 @@ export declare namespace GeneratedTaskPrioritySet {
          */
         id: string;
         /**
-         * Its priority as its source reads it back after the write.
+         * 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.
          */
         priority: ("none" | "urgent" | "high" | "medium" | "low");
         /**
@@ -13027,19 +13652,54 @@ export declare namespace GeneratedTaskPrioritySet {
         [k: string]: any;
     }
     /**
-     * What each mutation of an expected write came to, built from the mutations' own responses.
+     * 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.
      */
     interface WriteResult {
         /**
-         * One per mutation sent, in the order sent.
+         * One per mutation an expected write sent, in the order sent — absent for a write made
+         * without `--expect`.
          */
-        parts: WritePart[];
+        parts?: (WritePart[] | null);
         /**
-         * The task's version after the write, where the last response determines it.
+         * A task's priority after the write — `null` for a project or a document, which carry
+         * none, and where an expected write that failed cannot say.
+         */
+        priority?: (Priority | null);
+        /**
+         * The item's status after the write, exactly as `task show` spells it — `null` for a
+         * document, which has none, and where an expected write that failed cannot say.
+         */
+        status?: (Status | null);
+        /**
+         * The item's version after the write, where the write's responses determine it.
          */
         version?: (string | null);
         [k: string]: any;
     }
+    /**
+     * 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".
+     */
+    interface Status {
+        /**
+         * The normalised value filters compare against.
+         */
+        category: ("draft" | "backlog" | "todo" | "queued" | "in-progress" | "done" | "cancelled" | "unknown");
+        /**
+         * The source's own label for this status.
+         */
+        name: string;
+        [k: string]: any;
+    }
     /**
      * What one command spent, summed over the sources in it that meter their own requests.
      *
@@ -13369,6 +14029,16 @@ export declare namespace GeneratedTaskStatusSet {
         outcome: "unknown";
         [k: string]: any;
     });
+    /**
+     * 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.
+     */
+    type Priority = ("none" | "urgent" | "high" | "medium" | "low");
     /**
      * What `task status set` answers with.
      */
@@ -13405,7 +14075,7 @@ export declare namespace GeneratedTaskStatusSet {
          * fallback read included — absent for a write made without `--expect`.
          */
         spent?: (Spent | null);
-        status: Status;
+        status: Status1;
         [k: string]: any;
     }
     /**
@@ -13453,19 +14123,54 @@ export declare namespace GeneratedTaskStatusSet {
         [k: string]: any;
     }
     /**
-     * What each mutation of an expected write came to, built from the mutations' own responses.
+     * 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.
      */
     interface WriteResult {
         /**
-         * One per mutation sent, in the order sent.
+         * One per mutation an expected write sent, in the order sent — absent for a write made
+         * without `--expect`.
+         */
+        parts?: (WritePart[] | null);
+        /**
+         * A task's priority after the write — `null` for a project or a document, which carry
+         * none, and where an expected write that failed cannot say.
+         */
+        priority?: (Priority | null);
+        /**
+         * The item's status after the write, exactly as `task show` spells it — `null` for a
+         * document, which has none, and where an expected write that failed cannot say.
          */
-        parts: WritePart[];
+        status?: (Status | null);
         /**
-         * The task's version after the write, where the last response determines it.
+         * The item's version after the write, where the write's responses determine it.
          */
         version?: (string | null);
         [k: string]: any;
     }
+    /**
+     * 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".
+     */
+    interface Status {
+        /**
+         * The normalised status vocabulary shared across every source.
+         */
+        category: ("draft" | "backlog" | "todo" | "queued" | "in-progress" | "done" | "cancelled" | "unknown");
+        /**
+         * The source's own label for this status.
+         */
+        name: string;
+        [k: string]: any;
+    }
     /**
      * What one command spent, summed over the sources in it that meter their own requests.
      *
@@ -13510,9 +14215,12 @@ export declare namespace GeneratedTaskStatusSet {
         [k: string]: any;
     }
     /**
-     * Its status as its source reads it back.
+     * 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".
      */
-    interface Status {
+    interface Status1 {
         /**
          * The normalised status vocabulary shared across every source.
          */
@@ -14039,6 +14747,16 @@ export declare namespace GeneratedTaskUpdated {
         outcome: "unknown";
         [k: string]: any;
     });
+    /**
+     * 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.
+     */
+    type Priority = ("none" | "urgent" | "high" | "medium" | "low");
     /**
      * One task named by another task's [`Task::delivers`] or [`Task::delivered_by`].
      *
@@ -14177,19 +14895,54 @@ export declare namespace GeneratedTaskUpdated {
         [k: string]: any;
     }
     /**
-     * What each mutation of an expected write came to, built from the mutations' own responses.
+     * 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.
      */
     interface WriteResult {
         /**
-         * One per mutation sent, in the order sent.
+         * One per mutation an expected write sent, in the order sent — absent for a write made
+         * without `--expect`.
+         */
+        parts?: (WritePart[] | null);
+        /**
+         * A task's priority after the write — `null` for a project or a document, which carry
+         * none, and where an expected write that failed cannot say.
+         */
+        priority?: (Priority | null);
+        /**
+         * The item's status after the write, exactly as `task show` spells it — `null` for a
+         * document, which has none, and where an expected write that failed cannot say.
          */
-        parts: WritePart[];
+        status?: (Status | null);
         /**
-         * The task's version after the write, where the last response determines it.
+         * The item's version after the write, where the write's responses determine it.
          */
         version?: (string | null);
         [k: string]: any;
     }
+    /**
+     * 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".
+     */
+    interface Status {
+        /**
+         * The normalised status vocabulary shared across every source.
+         */
+        category: ("draft" | "backlog" | "todo" | "queued" | "in-progress" | "done" | "cancelled" | "unknown");
+        /**
+         * The source's own label for this status.
+         */
+        name: string;
+        [k: string]: any;
+    }
     /**
      * What one command spent, summed over the sources in it that meter their own requests.
      *
@@ -14345,7 +15098,7 @@ export declare namespace GeneratedTaskUpdated {
          * repeats.
          */
         repositories?: Repository[];
-        status: Status;
+        status: Status1;
         /**
          * The one-line summary a user recognises the task by.
          */
@@ -14402,7 +15155,7 @@ export declare namespace GeneratedTaskUpdated {
     /**
      * The source's status, normalised and preserved.
      */
-    interface Status {
+    interface Status1 {
         /**
          * The normalised status vocabulary shared across every source.
          */