@catalyst-cloud/sdk 0.13.1 → 0.14.1

package/dist/tenant-client.d.ts

@@ -1,36 +1,808 @@
-import { type LinearIdentityResult } from "./linear-identity.js";
-import type { IssueDetailView, IssueView, ProjectView, PullDetailView, PullView } from "@catalyst-cloud/read-model";
-import { type AuthStrategy } from "./live-sync-client.js";
-import { type TenantContract } from "./tenant-contract.js";
+// Generated by dts-bundle-generator v9.5.1
+
+export type MemberLinearIdentity = {
+	resolution: "unattempted" | "no_email" | "no_match";
+} | {
+	resolution: "resolved";
+	linearUserId: string;
+	resolvedAt: number;
+} | {
+	resolution: "manual";
+	linearUserId: string;
+	resolvedAt: number;
+	resolvedBy: string | null;
+};
+export interface LinearIdentityOption {
+	id: string;
+	name: string | null;
+	displayName: string | null;
+	avatarUrl: string | null;
+}
+export interface LinearIdentityView {
+	identity: MemberLinearIdentity;
+	/** Absent means no choice was offered, including a temporarily unreadable roster. */
+	options?: LinearIdentityOption[];
+}
+export type LinearIdentityResult = ({
+	outcome: "ok";
+} & LinearIdentityView) | {
+	outcome: "conflict";
+	status: 409;
+	reason: "already_resolved" | "already_claimed" | "identity_changed";
+} | TenantClientFailure;
+/** A bindable / storable SQLite scalar (matches the Workers `SqlStorageValue`). */
+export type SqlValue = string | number | null | ArrayBuffer;
+/**
+ * CTC-1912 — the "Blocked on an ask" chip's payload: the OPEN ask-labelled issue whose `blocks` edge
+ * points at this row, oldest wins when several cover it. `null` when nothing open and ask-labelled
+ * blocks this row.
+ */
+export interface BlockedOnAskView {
+	ask_identifier: SqlValue;
+	ask_assignee_id: SqlValue;
+	ask_assignee_name: SqlValue;
+	ask_created_at: SqlValue;
+}
+/** A denormalized label chip on an issue row. */
+export interface IssueLabelView {
+	id: string;
+	name: SqlValue;
+	/** The real Linear label color (CTC-37); null until captured (UI falls back to a hash tint). */
+	color: SqlValue;
+}
+/** A denormalized relation edge on an issue row (joined to the issue by identifier, not id). */
+export interface IssueRelationView {
+	/** The relation's own stable Linear id (relations.id PK, CTC-147) — distinct from the JOIN key
+	 *  (issue_identifier). Lets a consumer key/dedupe edges without inferring an id from the endpoints. */
+	id: SqlValue;
+	type: SqlValue;
+	issue_identifier: SqlValue;
+	related_identifier: SqlValue;
+	/**
+	 * CTC-885: the workflow-state NAME of the issue on the FAR end of this edge, resolved at READ
+	 * time; NULL when that issue is not mirrored (or is soft-deleted).
+	 *
+	 * ⛔ NULL MEANS "WE COULD NOT RESOLVE IT", NOT "IT IS OPEN" — 22 of 929 live `blocks` edges point
+	 * at an identifier with no `issues` row (cross-team targets the workspace-wide `issueRelations`
+	 * query surfaces but the sweep does not mirror). Reading NULL as open is the bug this field
+	 * exists to make impossible; every consumer must branch on it.
+	 *
+	 * ⛔ DERIVED, NEVER STORED. A `relations.related_state` column would be written under the
+	 * `updated_at`-guarded LWW upsert keyed on the RELATION's updatedAt (linear-reconcile.ts:1030-1056)
+	 * — and a far-end state change does not touch the edge, so the guard would refuse the write and
+	 * freeze the value forever. The exact bug CTC-885 reports would survive its own fix, invisibly.
+	 */
+	related_state: SqlValue;
+}
+/** One issue row for the list view — snake_case mirror columns + denormalized labels/relations. */
+export interface IssueView {
+	id: string;
+	identifier: SqlValue;
+	title: SqlValue;
+	state: SqlValue;
+	/** The workflow state's stable Linear id (CTC-148) — behind the `state` name. */
+	state_id: SqlValue;
+	/** Effective Linear workflow type, derived for partial webhook snapshots (CTC-1587). */
+	state_type: SqlValue;
+	assignee: SqlValue;
+	/** Assignee identity (CTC-USERS) — the users.id FK + the resolved name/avatar, so the card renders
+	 *  an avatar instead of a gray "Unknown" chip. `assignee_name` falls back to the legacy `assignee`
+	 *  name string when the user isn't mirrored; `assignee_avatar_url` is null when unresolved. */
+	assignee_id: SqlValue;
+	assignee_name: SqlValue;
+	assignee_avatar_url: SqlValue;
+	/**
+	 * The delegate AGENT's `users.id` FK, or null when nobody is acting on this issue (CTC-552).
+	 *
+	 * ⚠️ PRESENCE, NOT DISPLAY — which is why this is the ONLY delegate field on the list row, while the
+	 * DETAIL view additionally resolves `delegate_name`/`delegate_avatar_url`. The consumer that needs a
+	 * delegate on a LIST is the per-member "Waiting on me" filter, and it asks only *is a delegate set at
+	 * all*. Resolving a name for every row of every page would buy a users lookup for nobody.
+	 *
+	 * ⛔ NULL HERE IS **NOT**, ON ITS OWN, A "SOMEONE IS WAITING ON YOU" SIGNAL — and reading it that way
+	 * is the specific mistake this field exists to make avoidable. An undelegated, human-assigned issue
+	 * is ALSO every fleet ticket's PRE-delegation state (`apps/mirror/src/write-proxy/delegate.ts`,
+	 * CTC-593, which is the only writer of Linear's `delegate` field). A filter built on
+	 * `delegate_id == null` alone therefore shows a member the entire fleet backlog nobody ever asked
+	 * them about. The clause that actually discriminates a genuine human ask is an OUTGOING `blocks`
+	 * relation — already carried on this same row in `relations[]`. Both clauses, or neither: this field
+	 * is half of a pair, and the other half is two lines down.
+	 */
+	delegate_id: SqlValue;
+	priority: SqlValue;
+	estimate: SqlValue;
+	project_id: SqlValue;
+	cycle_id: SqlValue;
+	team_id: SqlValue;
+	/** Denormalized team key + name (CTC-148) — label a row's team without a teams lookup; team_id kept. */
+	team_key: SqlValue;
+	team_name: SqlValue;
+	/** The manual drag-rank (CTC-TICKET-FIELDS) — Linear sortOrder; carried on the list row so a future
+	 *  sort-by-rank can order without a detail round-trip. Null until captured. */
+	sort_order: SqlValue;
+	updated_at: SqlValue;
+	labels: IssueLabelView[];
+	relations: IssueRelationView[];
+	/** The raiser (CTC-867) — who raised the ask, sourced from the issue's Linear creator. Stored
+	 *  inline on the issue row (comments.author_* precedent), so no `users` JOIN is needed. Null when
+	 *  the issue has no recorded creator (never a fabricated "Unknown"). */
+	raiser: {
+		name: SqlValue;
+		avatarUrl: SqlValue;
+	} | null;
+	/** CTC-1736 — the asks that already NAME this issue, Done ones included. See {@link CoveringAskView}. */
+	covering_asks: CoveringAskView[];
+	/** CTC-1912 — the OPEN ask-labelled issue whose `blocks` edge points at this row (oldest wins),
+	 *  derived at read time (see {@link resolveBlockedOnAsk}). Null when nothing holds this ticket. */
+	blocked_on_ask: BlockedOnAskView | null;
+}
+/**
+ * CTC-1736 — an ask that already names this issue, whether or not it is still open.
+ *
+ * ⛔ WHY THIS EXISTS AS A COLUMN AT ALL. Both arms of `waitingOnMeClause` gate on `notDone`, so a
+ * covering ask that has been ANSWERED is excluded from the page for exactly the reason any other
+ * Done ticket is — and the ask→subject `blocks` edge lives on the ASK's row, not on the subject's.
+ * The instant the ask is answered, the page carries no evidence it ever existed, and the surface
+ * reported "no ask has been raised for it yet" about a ticket whose ask had been raised AND
+ * answered. That sentence is what CTC-1736 is.
+ *
+ * ⛔ AN ANNOTATION, NOT A PREDICATE. Nothing here narrows any row set. CTC-607's rule (an inference
+ * may add to a declaration, never veto it) is preserved because there is no veto anywhere in this
+ * field's construction — it is SELECT-list only.
+ *
+ * ⛔ NOT VIEWER-SCOPED, unlike `notAlreadyAsked`'s `ai.assignee_id = ?`. Suppression must be
+ * viewer-scoped; a CAPTION must not be. An ask raised about this ticket and assigned to somebody
+ * else was still raised about this ticket. `assignee_id` rides along as data for any consumer that
+ * does need to scope.
+ *
+ * ⚠️ REACHED ONLY THROUGH A RELATION EDGE. The join is `relations` (`type IN ('blocks',
+ * 'related')`, ask → this issue), so an ask that names this ticket in its TITLE but carries no
+ * relation to it at all is invisible here and the row still renders the "no ask has been raised"
+ * caption. That is AC1's own scope for CTC-1736 ("an ask exists whose `blocks` edges include ticket
+ * T"), not an oversight — but `waiting-on-me.ts`'s CTC-607 note records a MEASURED `catalyst-ask`
+ * with zero blocking relations, so the gap is real and stated here rather than rediscovered.
+ *
+ * ⭐ CTC-2890 validate remediation (attempt 1, code-review CR-3) — `related` JOINED `blocks` HERE.
+ * CTC-2890 stops an auto-raised ask from carrying a `blocks` edge to the ticket it is about; it
+ * attaches an informing `related` edge instead. Every covering-ask and `blockedOnAsk` reader in this
+ * module reached an ask through `type = 'blocks'` alone, so after that change a held ticket had an
+ * open ask naming it and the UI said no ask covered it — the same unreadability CTC-2890 was raised
+ * out of, one surface over. The widening cannot pull in a non-ask: the other end of the join is
+ * constrained to the ask label family by `openAskBlockerConditions` (or `ASK_LABEL` on the page-scoped
+ * read), so the only new rows are asks a human or a raiser deliberately linked to this ticket.
+ *
+ * ⚠️ CAPPED AT {@link MAX_COVERING_ASKS} PER ROW, ordered subject-first then open-first then
+ * newest. ⛔ Therefore NEVER derive a COUNT from this array — it is a sample, not a tally
+ * (ADR-0049's rule, one surface over). Naming an entry is the only sanctioned use.
+ */
+export interface CoveringAskView {
+	identifier: SqlValue;
+	title: SqlValue;
+	state: SqlValue;
+	/** Whose ask it is. Data, not a filter — see the interface doc. */
+	assignee_id: SqlValue;
+	/** The ask's title names THIS row as its subject (`Unblock <identifier> …`) rather than merely
+	 *  carrying a `blocks` edge to it. The chain carve-out CTC-1337 records depends on the
+	 *  difference: an ask about A also blocks B, and B is a genuine unasked-about blocker. */
+	subject: boolean;
+	/** The ask's own state normalizes into {@link ANSWERED_STATE_KEYS} — i.e. a member actually
+	 *  answered it. ⛔ NOT `DONE_STATE_KEYS` (validate-round Finding 1, 2026-09-06): that list means
+	 *  "finished" and folds `canceled`/`cancelled`/`duplicate` in with `done`, so an ask closed WITHOUT
+	 *  a decision would read as answered. See `closedUnanswered` for that case. */
+	resolved: boolean;
+	/** The ask was closed WITHOUT a decision — canceled or marked a duplicate — as distinct from
+	 *  genuinely {@link resolved}. Mutually exclusive with `resolved`; both false while the ask is
+	 *  still open. */
+	closedUnanswered: boolean;
+}
+/** A denormalized comment on an issue detail view. */
+export interface IssueCommentView {
+	id: SqlValue;
+	body: SqlValue;
+	/** Comment author + threading (CTC-42): name/avatar for the header, is_bot for the agent marker,
+	 *  parent_id for reply nesting. All nullable (a pre-backfill / bot comment may lack them). */
+	author_id: SqlValue;
+	author_name: SqlValue;
+	author_avatar_url: SqlValue;
+	is_bot: SqlValue;
+	parent_id: SqlValue;
+	/** CTC-744 — Comment.createdAt, so a thread's REPLIES sort in created order rather than
+	 *  last-edited order. Nullable: the column predates the backfill on some rows. The list's own
+	 *  `ORDER BY updated_at` is unchanged — this only orders replies WITHIN a thread. */
+	created_at: SqlValue;
+	updated_at: SqlValue;
+}
+/**
+ * CTC-524 — an agent session on the issue detail, with its activity stream.
+ *
+ * ⛔ RAW STATE, NOT A VERDICT. `status` is Linear's own (`active` / `awaitingInput` / `complete` /
+ * `error`) and `updated_at` is when it last moved. CTC-503's abandoned-vs-awaiting distinction is
+ * DERIVED from the two by the reader — deliberately not decided here, because a threshold baked into
+ * the read-model is inherited by every consumer that had no say in it and cannot see it.
+ */
+export interface IssueAgentSessionView {
+	id: SqlValue;
+	status: SqlValue;
+	app_user_id: SqlValue;
+	/** ⚠️ Frequently NULL — a session the app created for itself has no human creator (ARCHITECT-7).
+	 *  That null is evidence, not a gap to paper over. */
+	creator_id: SqlValue;
+	created_at: SqlValue;
+	updated_at: SqlValue;
+	activities: IssueAgentActivityView[];
+}
+/** One activity in a session's stream. `type` carries the notify semantics (CTC-501) — an
+ *  `elicitation` reached a human's Inbox, a `thought` did not. */
+export interface IssueAgentActivityView {
+	id: SqlValue;
+	type: SqlValue;
+	body: SqlValue;
+	/** CTC-1089 — an `action` activity's fields (Linear's ActionContent carries NO `body`), promoted
+	 *  out of `raw`. Null for every other activity type. */
+	action: SqlValue;
+	parameter: SqlValue;
+	result: SqlValue;
+	signal: SqlValue;
+	created_at: SqlValue;
+}
+/**
+ * A resolved label reference on an activity event (CTC-17). `id` is ALWAYS present (the event really
+ * touched that label); `name`/`color` resolve from `labels` REGARDLESS of removed_at — a label deleted
+ * AFTER the event still names its past row in the historical timeline — and stay null when the id isn't
+ * mirrored (never fabricated). This differs from the LIVE label chips on the issue row, which DO filter
+ * removed_at: those show current state, this shows history.
+ */
+export interface IssueActivityLabelRef {
+	id: SqlValue;
+	name: SqlValue;
+	color: SqlValue;
+}
+/**
+ * One materialized IssueHistory event on an issue's timeline (CTC-17) — the TRANSITIONS the live
+ * `issues` row structurally can't express (it stores only the current value + a single actor that each
+ * write clobbers). Sourced from the immutable `issue_history` table (CTC-14), ordered by `created_at`
+ * (the timeline sort key, ms epoch) so the UI can interleave these rows against comment timestamps.
+ *
+ * The id-bearing transition fields are resolved to display values AT READ TIME — the read-model owns
+ * Linear-id → display resolution so the UI stays dumb and never needs a Linear-domain lookup table:
+ *   • `actor_id`, `from/to_assignee_id` → `users` (name; actor also carries avatar)
+ *   • `from/to_project_id` → project name · `from/to_cycle_id` → cycle number
+ *   • `from/to_parent_id` → issue identifier · label-id arrays → {id,name,color}
+ * Every resolution is GUARDED (a null id resolves to null; an unmirrored id stays null — never
+ * fabricated) and HISTORICAL (no removed_at filter — a since-deleted label/project/parent still names
+ * its past event). `from/to_team_id` stay RAW ids (the mirror has no teams table to resolve against).
+ *
+ * Raw scalars the UI formats itself: `from/to_state` are workflow state NAMES already; `from/to_priority`
+ * are the Linear 0-4 priority enum; `from/to_estimate` are points; `from/to_title` are strings;
+ * `from/to_due_date` are TimelessDate "YYYY-MM-DD" strings AS-IS (NEVER a timestamp — the trap). The
+ * booleans are NULL-PRESERVING: `null` = the event did not touch the property, `0` = an explicit false
+ * transition (unarchive/untrash), `1` = true. Collapsing null→false would fabricate "no change" as false.
+ */
+export interface IssueActivityView {
+	id: SqlValue;
+	/** Event time (ms epoch) — the timeline sort key the UI interleaves against comment `updated_at`. */
+	created_at: SqlValue;
+	actor_id: SqlValue;
+	actor_name: SqlValue;
+	actor_avatar_url: SqlValue;
+	/** Workflow state transition — NAMES already (issues store state as a name; there is no states table). */
+	from_state: SqlValue;
+	to_state: SqlValue;
+	/** Assignee transition — the raw ids plus the resolved display names (null when unmirrored/unset). */
+	from_assignee_id: SqlValue;
+	from_assignee_name: SqlValue;
+	to_assignee_id: SqlValue;
+	to_assignee_name: SqlValue;
+	from_priority: SqlValue;
+	to_priority: SqlValue;
+	from_estimate: SqlValue;
+	to_estimate: SqlValue;
+	from_title: SqlValue;
+	to_title: SqlValue;
+	/** Cycle transition — the raw ids plus the resolved cycle numbers. */
+	from_cycle_id: SqlValue;
+	from_cycle_number: SqlValue;
+	to_cycle_id: SqlValue;
+	to_cycle_number: SqlValue;
+	/** Project transition — the raw ids plus the resolved project names. */
+	from_project_id: SqlValue;
+	from_project_name: SqlValue;
+	to_project_id: SqlValue;
+	to_project_name: SqlValue;
+	/** Parent-issue transition — the raw ids plus the resolved issue identifiers. */
+	from_parent_id: SqlValue;
+	from_parent_identifier: SqlValue;
+	to_parent_id: SqlValue;
+	to_parent_identifier: SqlValue;
+	/** Team transition — RAW ids (no teams table to resolve a name from). */
+	from_team_id: SqlValue;
+	to_team_id: SqlValue;
+	/** TimelessDate "YYYY-MM-DD" strings AS-IS (NEVER a timestamp). */
+	from_due_date: SqlValue;
+	to_due_date: SqlValue;
+	/** Labels added/removed in this event — resolved to {id,name,color} (historical; see IssueActivityLabelRef). */
+	added_labels: IssueActivityLabelRef[];
+	removed_labels: IssueActivityLabelRef[];
+	/** NULL-PRESERVING booleans — null = untouched, 0 = explicit false, 1 = true (see the interface doc). */
+	updated_description: SqlValue;
+	archived: SqlValue;
+	auto_archived: SqlValue;
+	auto_closed: SqlValue;
+	trashed: SqlValue;
+}
+/**
+ * The single-issue detail view — the OPEN UI detail-pane surface. Reuses the EXACT join shapes
+ * buildIssuesView uses (labels via issue_labels JOIN labels scoped to this issue_id; relations by
+ * IDENTIFIER), plus the issue's live comments. `description` (CTC-35), the delegate/bot actor
+ * (CTC-38), and the parent-issue pointer (CTC-39) ride this DETAIL fetch only — they are deliberately
+ * NOT in buildIssuesView / the SSE list row (keeps the list payload + apply path small).
+ *
+ * The raw `project_id`/`cycle_id` foreign keys are resolved to human-readable display values (CTC-36)
+ * so the rail renders names + lifecycle context, not UUIDs: `project_name`/`project_state` and
+ * `cycle_number`/`cycle_starts_at`/`cycle_ends_at`. Resolved by separate guarded lookups (NOT a JOIN —
+ * keeps the issue SELECT byte-identical and avoids ambiguous `id` columns); all stay null when the FK
+ * is null OR the referenced project/cycle isn't mirrored yet (never fabricated). Cycles carry only a
+ * `number` + start/end ms epochs in the mirror (schema.sql:51) — the client formats "Cycle N" + dates.
+ */
+export interface IssueDetailView {
+	id: string;
+	identifier: SqlValue;
+	title: SqlValue;
+	/** The issue's markdown description (CTC-35) — detail-only; null when absent. */
+	description: SqlValue;
+	state: SqlValue;
+	/** The workflow state's stable Linear id (CTC-148) — behind the `state` name. */
+	state_id: SqlValue;
+	assignee: SqlValue;
+	/** Assignee identity (CTC-USERS): the FK + resolved name/avatar (null when the user isn't mirrored —
+	 *  never fabricated). `assignee_name` falls back to the legacy `assignee` name string. */
+	assignee_id: SqlValue;
+	assignee_name: SqlValue;
+	assignee_avatar_url: SqlValue;
+	priority: SqlValue;
+	estimate: SqlValue;
+	project_id: SqlValue;
+	project_name: SqlValue;
+	project_state: SqlValue;
+	/** Project enrichment (CTC-HIERARCHY) — resolved alongside project_name; null when unmirrored. */
+	project_description: SqlValue;
+	project_progress: SqlValue;
+	project_health: SqlValue;
+	cycle_id: SqlValue;
+	cycle_number: SqlValue;
+	/** The cycle's display name (cycles.name, CTC-147) — null when the cycle is unnamed or unmirrored.
+	 *  Resolved alongside cycle_number; lets the UI label a cycle without a separate lookup. */
+	cycle_name: SqlValue;
+	cycle_starts_at: SqlValue;
+	cycle_ends_at: SqlValue;
+	team_id: SqlValue;
+	/** Denormalized team key + name (CTC-148) — label the issue's team without a teams lookup; team_id kept. */
+	team_key: SqlValue;
+	team_name: SqlValue;
+	/** Delegate (agent) + bot/last-actor (CTC-38) — null for human-assigned tickets. */
+	delegate_id: SqlValue;
+	delegate_name: SqlValue;
+	/** The delegate AGENT's avatar (CTC-USERS) — resolved delegate_id → users; null when unmirrored. */
+	delegate_avatar_url: SqlValue;
+	bot_actor_name: SqlValue;
+	bot_actor_type: SqlValue;
+	bot_actor_sub_type: SqlValue;
+	/** Parent-issue pointer (CTC-39) — null for top-level issues. */
+	parent_id: SqlValue;
+	parent_identifier: SqlValue;
+	/** Ticket field enrichment (CTC-TICKET-FIELDS) — the Linear deep-link, the lifecycle timestamps
+	 *  (ms epochs), the due date (TimelessDate string, NOT a timestamp), the human priority label, and
+	 *  the manual drag-rank. All nullable (a pre-backfill row, or a state the issue hasn't reached). */
+	url: SqlValue;
+	started_at: SqlValue;
+	completed_at: SqlValue;
+	canceled_at: SqlValue;
+	created_at: SqlValue;
+	due_date: SqlValue;
+	priority_label: SqlValue;
+	sort_order: SqlValue;
+	updated_at: SqlValue;
+	comments: IssueCommentView[];
+	/** CTC-524 — agent sessions on this issue, newest first, each with its activities. */
+	agent_sessions: IssueAgentSessionView[];
+	/** The interleavable activity timeline (CTC-17) — issue_history transitions ordered by created_at,
+	 *  with ids resolved to display values. The UI merges this with `comments` by timestamp. Empty []
+	 *  when the issue has no captured history (a fresh issue, or one created before history backfill). */
+	activity: IssueActivityView[];
+	labels: IssueLabelView[];
+	relations: IssueRelationView[];
+	/** The PRs that reference this ticket (CTC-269) — the ticket→PR side of the cross-link. Reverse
+	 *  lookup on `pull_requests.linear_issue_identifier`; empty [] when no mirrored PR names this key. */
+	linked_pulls: IssueLinkedPullView[];
+}
+/** A PR that references an issue (CTC-269) — the ticket→PR reverse-lookup row. Carries just enough to
+ *  render the Relations card row (a state dot + title) and deep-link straight to the PR on GitHub
+ *  (`repo_id` + `number`, CTC-1537) without a second fetch. `node_id` is retained only as a React key —
+ *  it plays no role in the link, which is always derivable since `repo_id`/`number` are non-nullable.
+ *  The client derives the review-state display from state/draft/merged (pull-presenter). */
+export interface IssueLinkedPullView {
+	repo_id: SqlValue;
+	number: SqlValue;
+	node_id: SqlValue;
+	title: SqlValue;
+	state: SqlValue;
+	draft: SqlValue;
+	merged: SqlValue;
+}
+/** A denormalized CI check pill on a PR row. */
+export interface PullCheckView {
+	name: SqlValue;
+	status: SqlValue;
+	conclusion: SqlValue;
+}
+/** One PR row for the list view — snake_case mirror columns + denormalized checks. */
+export interface PullView {
+	repo_id: SqlValue;
+	number: SqlValue;
+	node_id: SqlValue;
+	/** PR data tier 1 (CTC-PR-TIER1): title (the #1 complaint), body, author, dates, comment count,
+	 *  milestone — all rode the fetched PR list/object (zero extra GitHub API calls). All nullable
+	 *  (a pre-backfill row, or a PR with no milestone, leaves them null). */
+	title: SqlValue;
+	body: SqlValue;
+	author_login: SqlValue;
+	author_avatar_url: SqlValue;
+	state: SqlValue;
+	draft: SqlValue;
+	merged: SqlValue;
+	merged_at: SqlValue;
+	head_sha: SqlValue;
+	base_ref: SqlValue;
+	mergeable: SqlValue;
+	mergeable_state: SqlValue;
+	auto_merge: SqlValue;
+	created_at: SqlValue;
+	closed_at: SqlValue;
+	comment_count: SqlValue;
+	milestone_title: SqlValue;
+	updated_at: SqlValue;
+	/** CTC-269: the PR's source branch (persisted) + the Linear ticket key parsed from the PR text.
+	 *  Both nullable (a pre-backfill row, or a PR whose text names no ticket). */
+	head_ref: SqlValue;
+	linear_issue_identifier: SqlValue;
+	checks: PullCheckView[];
+	/** CTC-312: 1 when the PR has any review with state COMMENTED or CHANGES_REQUESTED
+	 *  (case-insensitive). The board's Remediate column reads this; the list view ignores it. */
+	has_review_signal: number;
+	/** CTC-312: 1 when the PR's head sha carries a legacy commit STATUS in a failing state
+	 *  (failure/error). The board's Remediate signal reads this so a repo that reports CI via the
+	 *  Status API (not the modern check_runs) still surfaces as failing; the list view ignores it. */
+	has_failing_status: number;
+	/** CTC-1912 — inherited from the linked ticket (`linear_issue_identifier`): the OPEN ask-labelled
+	 *  issue blocking that ticket, oldest wins. Null when the PR names no ticket, or that ticket is
+	 *  unheld. Derived at read time, same helper as `IssueView.blocked_on_ask`. */
+	blocked_on_ask: BlockedOnAskView | null;
+}
+/** A review on a PR (CTC-125) — the resolved reviewer + verdict state. `reviews` DOES carry a `body`
+ *  column (CTC-575), but this view does not select it — only the state (APPROVED / CHANGES_REQUESTED /
+ *  COMMENTED) shows; surfacing the review text is a UX-consumer concern tracked separately. */
+export interface PullReviewView {
+	review_id: SqlValue;
+	/** The reviewer's stable Linear/GitHub user id (reviews.user_id) — the collision-free key for
+	 *  collapsing a reviewer's history to one effective verdict (CTC-357 review). `reviewer_name` is a
+	 *  nullable, non-unique display name and must NOT be used for grouping. */
+	reviewer_id: SqlValue;
+	reviewer_name: SqlValue;
+	reviewer_avatar_url: SqlValue;
+	state: SqlValue;
+	submitted_at: SqlValue;
+}
+/** A legacy commit-status context on a PR's head sha (CTC-125) — the GitHub Status API (distinct from
+ *  the modern check_runs). Often empty by design when CI reports via check_runs instead. */
+export interface PullStatusView {
+	context: SqlValue;
+	state: SqlValue;
+	target_url: SqlValue;
+	updated_at: SqlValue;
+}
+/** One PR's full detail (CTC-125) — the list `PullView` columns PLUS the already-ingested reviews +
+ *  commit_statuses (never surfaced before). Keyed by `node_id`. `checks[]` joins by head_sha (modern
+ *  Actions report here — lead with these); `commit_statuses[]` is the legacy Status API. */
+export interface PullDetailView {
+	repo_id: SqlValue;
+	number: SqlValue;
+	node_id: SqlValue;
+	title: SqlValue;
+	body: SqlValue;
+	author_login: SqlValue;
+	author_avatar_url: SqlValue;
+	state: SqlValue;
+	draft: SqlValue;
+	merged: SqlValue;
+	merged_at: SqlValue;
+	head_sha: SqlValue;
+	base_ref: SqlValue;
+	mergeable: SqlValue;
+	mergeable_state: SqlValue;
+	auto_merge: SqlValue;
+	created_at: SqlValue;
+	closed_at: SqlValue;
+	comment_count: SqlValue;
+	milestone_title: SqlValue;
+	updated_at: SqlValue;
+	/** CTC-269 ticket↔PR link. `head_ref` is the persisted source branch; `linear_issue_identifier`
+	 *  the ticket key parsed from the PR text; `linked_issue_state` that issue's live workflow state
+	 *  resolved from the mirror (null when the PR names no ticket OR the named issue isn't mirrored —
+	 *  never fabricated). The client renders the ticket chip + its state and deep-links to /tickets. */
+	head_ref: SqlValue;
+	linear_issue_identifier: SqlValue;
+	linked_issue_state: SqlValue;
+	checks: PullCheckView[];
+	reviews: PullReviewView[];
+	commit_statuses: PullStatusView[];
+	/** CTC-1912 — same as `PullView.blocked_on_ask`. Not existence-gated on the linked issue's row
+	 *  (unlike `linear_issue_identifier`/`linked_issue_state`): the edge itself is the evidence. */
+	blocked_on_ask: BlockedOnAskView | null;
+}
+/** A denormalized parent-initiative reference on a project row (via project_initiatives).
+ *  `id` is always present (the edge exists); `name` resolves from the initiatives table and is
+ *  null when that initiative isn't mirrored — never fabricated. */
+export interface ProjectInitiativeRef {
+	id: string;
+	name: SqlValue;
+}
+/** One project row for the list view — snake_case mirror columns + resolved lead + parent initiatives.
+ *  `target_date`/`start_date` are Linear TimelessDate "YYYY-MM-DD" strings AS-IS (NEVER a timestamp). */
+export interface ProjectView {
+	id: string;
+	name: SqlValue;
+	state: SqlValue;
+	description: SqlValue;
+	/** The project lead identity (CTC-HIERARCHY): the users.id FK + resolved name/avatar (null when the
+	 *  user isn't mirrored — never fabricated). */
+	lead_id: SqlValue;
+	lead_name: SqlValue;
+	lead_avatar_url: SqlValue;
+	target_date: SqlValue;
+	start_date: SqlValue;
+	progress: SqlValue;
+	health: SqlValue;
+	icon: SqlValue;
+	color: SqlValue;
+	updated_at: SqlValue;
+	/** The initiatives this project belongs to (many:many via project_initiatives). [] when none. */
+	initiatives: ProjectInitiativeRef[];
+}
+/**
+ * How the consumer proves it may open `/connect`.
+ *
+ *  • `token`  — a service bearer token. The WHATWG WebSocket constructor
+ *    cannot set an Authorization header, so the token rides the URL as `?token=`. The service
+ *    constant-time compares it and STRIPS it before forwarding internally. Use this ONLY on a
+ *    trusted backend — never the browser.
+ *  • `cookie` — append NOTHING to the URL. The browser's same-origin session cookie rides the
+ *    WebSocket upgrade automatically. This makes it impossible to leak a token from the browser path.
+ *  • `bearer` — a person's OAuth access token, resolved by `getToken()` and awaited FRESH on every
+ *    (re)connect and every /snapshot fetch (CTC-2111). The token is short-lived (a WorkOS user access
+ *    token, ~15 min) and rotates underneath a running client, so unlike `token` it is NEVER captured
+ *    once. Its resolved value rides `?token=` exactly as the `token` strategy's value does. Pair it
+ *    with `onAuthError` + the `"auth-required"` status: a mirror close code 4401 means re-authenticate
+ *    (revocation / inactivity), and the client STOPS reconnecting rather than hammering a dead token.
+ */
+export type AuthStrategy = {
+	kind: "token";
+	token: string;
+} | {
+	kind: "cookie";
+} | {
+	kind: "bearer";
+	getToken: () => Promise<string>;
+};
+/** The eleven stage slots `teams[].stages` is keyed by. Served as `slots` on the wire, in this order. */
+export type WorkflowSlot = "dispatch" | "intake" | "research" | "plan" | "implement" | "remediate" | "verify" | "review" | "pr" | "done" | "canceled";
+/** ⛔ `unscoped`, NOT `workspace` — the mirror's `labels.team_id` is advisory (NULL means either
+ *  "genuinely workspace-scoped" or "not re-stamped yet"), so the document reports what was read. */
+export type LabelScopeKind = "unscoped" | "team" | "absent";
+export interface ContractLabel {
+	name: string;
+	unscopedId: string | null;
+	teamScopedId: string | null;
+	scope: LabelScopeKind;
+	/** The id `scope` resolves to (the unscoped copy wins); `null` when `scope` is `absent`. */
+	preferredId: string | null;
+}
+export interface ContractStage {
+	/** Linear's state id — THE join key. Address stages by slot, and states by this. */
+	stateId: string;
+	/** The state's CURRENT name, read live — never the mapping's write-time snapshot. */
+	name: string | null;
+	type: string | null;
+	/** False when the mapped id is not in the team's live stage set (archived, or re-minted). */
+	stateStillExists: boolean;
+	/** How the mapping was made: created | matched | chosen. */
+	source: string;
+}
+export interface ContractReadinessCheck {
+	id: string;
+	state: "pass" | "fail" | "unknown";
+	reason?: string;
+	count?: number;
+}
+export interface ContractTeam {
+	id: string;
+	key: string | null;
+	name: string | null;
+	workflowMode: string;
+	gitAutomation: string;
+	/** Keyed by slot. An UNMAPPED slot is ABSENT — never a placeholder. */
+	stages: Partial<Record<WorkflowSlot, ContractStage>>;
+	labels: {
+		ask: ContractLabel[];
+		hold: ContractLabel[];
+		release: ContractLabel[];
+	};
+	readiness: {
+		/** `unchecked` means no verdict has ever been computed — a real answer, not `blocked`. */
+		status: "ready" | "degraded" | "blocked" | "unchecked";
+		checks: ContractReadinessCheck[];
+		checkedAt: number | null;
+		expiresAt: number | null;
+		workflowRev: number | null;
+	};
+}
+export type ContractRoute = {
+	method: "GET" | "POST";
+	path: string;
+	/** Whether a call spends a unit of the per-host daily write budget. */
+	takesWriteBudgetUnit: boolean;
+	/** The contract version this route first appeared in. */
+	since: string;
+} | {
+	method: "PUT";
+	path: "/api/v1/agent/tenant/review-agents/write";
+	takesWriteBudgetUnit: false;
+	since: "2.8.0";
+	idempotencyKeyField: null;
+};
+export interface ContractMergeRepository {
+	repoId: string;
+	owner: string;
+	name: string;
+	/** The EFFECTIVE policy after repo-wins-over-tenant precedence. */
+	policy: string;
+	policySource: "repo" | "tenant" | "default";
+}
+export interface ContractMergeCleanPassShape {
+	kind: string;
+	description: string;
+	/** FALSE means the cloud does NOT accept this shape today. */
+	honoured: boolean;
+	ticket: string | null;
+}
+export interface ContractAdvanceRule {
+	phase: string;
+	result: "ok" | "failed";
+	fromSlots: readonly WorkflowSlot[] | null;
+	toSlot: WorkflowSlot | null;
+	because: string;
+}
+export interface TenantContract {
+	/** Semver over the DOCUMENT'S SHAPE (MAJOR: meaning changed/removed; MINOR: additive). */
+	contractVersion: string;
+	protocolVersion: number;
+	/** The cloud states the freshness bounds; the CLIENT measures its own age against them. */
+	cache: {
+		maxAgeSeconds: number;
+		staleRefusalSeconds: number;
+	};
+	account: {
+		id: string;
+		slug: string;
+		name: string;
+		linearWorkspaceId: string | null;
+		linearWorkspaceSlug: string | null;
+	};
+	apiPrefix: string;
+	slots: readonly WorkflowSlot[];
+	routes: readonly ContractRoute[];
+	teams: ContractTeam[];
+	vocabulary: {
+		askLabelPrefix: string;
+		askPhaseLabelPrefix: string;
+		askMarkerLabel: string;
+		releaseLabel: string;
+		bookkeeping: {
+			marker: string;
+			prefixOnly: boolean;
+			asciiCaseInsensitive: boolean;
+			leadingWhitespaceTrimmed: boolean;
+		};
+	};
+	askTemplate: {
+		headings: {
+			ask: string;
+			options: string;
+			defaultIfSilent: string;
+			howToAnswer: string;
+		};
+		howToAnswer: {
+			withOptions: string;
+			withoutOptions: string;
+		};
+		optionBulletFormat: string;
+		maxLetteredOptions: number;
+		maxAskGenerations: number;
+		example: string;
+	};
+	ladder: {
+		phases: readonly string[];
+		keying: string;
+		keyingScope: string;
+		/** `phases` is the full vocabulary; this says whether `intake` actually runs. */
+		intakeEnabled: boolean;
+		advance: readonly ContractAdvanceRule[];
+	};
+	thresholds: {
+		scope: string;
+		parkAfterConsecutiveFailures: number;
+		remediateRoundCap: number;
+		remediateEscalatedRoundBudget: number;
+		remediateRewindBudget: number;
+		retryBackoffMs: readonly number[];
+		hostDailyWriteBudget: number;
+	};
+	merge: {
+		policies: readonly string[];
+		defaultPolicy: string;
+		repositories: readonly ContractMergeRepository[];
+		reviewerLogin: string;
+		cleanPassShapes: readonly ContractMergeCleanPassShape[];
+		cloudRemediateRequiredChecks: readonly string[];
+		prLabels: {
+			queueReady: string;
+			handStepsHold: string;
+			hold: string;
+			preview: string;
+		};
+	};
+	readinessChecks: readonly {
+		id: string;
+		severity: string;
+		needsAnswer: boolean;
+	}[];
+	humans: readonly {
+		linearUserId: string;
+		role: "owner" | "admin";
+	}[];
+	asks: {
+		/** `null` means NOT CONFIGURED, and a consumer must refuse rather than guess. */
+		approvalsTeamId: string | null;
+	};
+}
 /** Default per-request deadline — the bundle's `REQUEST_TIMEOUT_MS`. */
 export declare const DEFAULT_TIMEOUT_MS = 15000;
 /** One cached contract: the document, the validator it came with, and when it was fetched. */
 export interface ContractCacheEntry {
-    etag: string | null;
-    /** Epoch ms of the fetch (or the last successful 304 revalidation). */
-    fetchedAt: number;
-    contractVersion: string;
-    doc: TenantContract;
+	etag: string | null;
+	/** Epoch ms of the fetch (or the last successful 304 revalidation). */
+	fetchedAt: number;
+	contractVersion: string;
+	doc: TenantContract;
 }
 /** Where the contract cache lives. In-memory by default; the bundle supplies a disk-backed one. */
 export interface ContractCacheStore {
-    get(): ContractCacheEntry | null | Promise<ContractCacheEntry | null>;
-    set(entry: ContractCacheEntry): void | Promise<void>;
+	get(): ContractCacheEntry | null | Promise<ContractCacheEntry | null>;
+	set(entry: ContractCacheEntry): void | Promise<void>;
 }
 /** The default store: one entry, held for the life of the client. */
 export declare function memoryContractCache(): ContractCacheStore;
 export interface TenantClientBaseOptions {
-    /** The service origin (e.g. "https://staging.catalystcloud.dev"). A trailing slash is trimmed;
-     *  every route path is absolute under it. */
-    baseUrl: string;
-    /** Injectable for tests; defaults to the platform global. */
-    fetch?: typeof fetch;
-    /** Per-request deadline in ms. Default {@link DEFAULT_TIMEOUT_MS}. */
-    timeoutMs?: number;
-    /** Default {@link memoryContractCache}. */
-    contractCache?: ContractCacheStore;
-    /** Epoch ms; injectable so a test can cross the cache bounds without sleeping. */
-    now?: () => number;
+	/** The service origin (e.g. "https://staging.catalystcloud.dev"). A trailing slash is trimmed;
+	 *  every route path is absolute under it. */
+	baseUrl: string;
+	/** Injectable for tests; defaults to the platform global. */
+	fetch?: typeof fetch;
+	/** Per-request deadline in ms. Default {@link DEFAULT_TIMEOUT_MS}. */
+	timeoutMs?: number;
+	/** Default {@link memoryContractCache}. */
+	contractCache?: ContractCacheStore;
+	/** Epoch ms; injectable so a test can cross the cache bounds without sleeping. */
+	now?: () => number;
 }
 /**
  * Exactly one credential. `key` is the CTC-2004 shape, kept working with identical wire behaviour;
@@ -40,14 +812,14 @@ export interface TenantClientBaseOptions {
  * normalized to `{kind:"token", token:key}` at construction, so `send()` never sees two shapes.
  */
 export type TenantClientOptions = TenantClientBaseOptions & ({
-    /** A tenant or personal key. Most agent proxy writes require an organization key;
-     *  `teamWorkflow` and personal connection methods require the caller's own personal key or
-     *  device login. */
-    key: string;
-    auth?: never;
+	/** A tenant or personal key. Most agent proxy writes require an organization key;
+	 *  `teamWorkflow` and personal connection methods require the caller's own personal key or
+	 *  device login. */
+	key: string;
+	auth?: never;
 } | {
-    auth: AuthStrategy;
-    key?: never;
+	auth: AuthStrategy;
+	key?: never;
 });
 /**
  * The arms ANY call can end in. Every arm the server produced carries its `status`; `network` is the
@@ -56,295 +828,295 @@ export type TenantClientOptions = TenantClientBaseOptions & ({
 export type TenantClientFailure = 
 /** 401 — the credential was not accepted. `ref` joins to the cloud's log line. */
 {
-    outcome: "unauthorized";
-    status: 401;
-    reason: string;
-    ref: string | null;
+	outcome: "unauthorized";
+	status: 401;
+	reason: string;
+	ref: string | null;
 }
 /** 403 — wrong principal class, wrong tenant, or a missing scope (`required` names it). */
  | {
-    outcome: "forbidden";
-    status: 403;
-    reason: string;
-    required: string | null;
-    account: string | null;
+	outcome: "forbidden";
+	status: 403;
+	reason: string;
+	required: string | null;
+	account: string | null;
 }
 /** 429 — the per-host daily write budget or the reserved Linear read floor. `retryAfterSeconds` is
  *  the server's own `Retry-After` when it sent one (the read floor does; the write budget does not). */
  | {
-    outcome: "rate-limited";
-    status: 429;
-    reason: string;
-    retryAfterSeconds: number | null;
+	outcome: "rate-limited";
+	status: 429;
+	reason: string;
+	retryAfterSeconds: number | null;
 }
 /** A 400-class NAMED refusal — malformed input, a bad cursor, a tenant with no Linear workspace. */
  | {
-    outcome: "rejected";
-    status: number;
-    reason: string;
-    attempts?: number;
+	outcome: "rejected";
+	status: number;
+	reason: string;
+	attempts?: number;
 }
 /** The server named a failure of its own (a 502 partial document, a 503 Linear client). */
  | {
-    outcome: "failed";
-    status: number;
-    reason: string;
+	outcome: "failed";
+	status: number;
+	reason: string;
 }
 /** fetch threw, or the deadline fired. */
  | {
-    outcome: "network";
-    reason: string;
+	outcome: "network";
+	reason: string;
 }
 /** The body was not JSON, or not the shape this route is documented to answer. */
  | {
-    outcome: "shape";
-    status: number;
-    reason: string;
+	outcome: "shape";
+	status: number;
+	reason: string;
 }
 /** Any other non-2xx. */
  | {
-    outcome: "http";
-    status: number;
-    reason: string;
+	outcome: "http";
+	status: number;
+	reason: string;
 };
 export type TeamWorkflowFailure = TenantClientFailure & {
-    error?: string;
+	error?: string;
 };
 export type TeamWorkflowResult<T> = ({
-    outcome: "ok";
-    status: number;
+	outcome: "ok";
+	status: number;
 } & T) | TeamWorkflowFailure;
 export interface TeamWorkflowReadiness {
-    teamId: string;
-    teamKey: string;
-    teamName: string;
-    status: "ready" | "degraded" | "blocked" | "unchecked";
-    checkedAt?: number;
-    checks: readonly TeamReadinessCheck[];
-    workflowRev: number;
-    [field: string]: unknown;
+	teamId: string;
+	teamKey: string;
+	teamName: string;
+	status: "ready" | "degraded" | "blocked" | "unchecked";
+	checkedAt?: number;
+	checks: readonly TeamReadinessCheck[];
+	workflowRev: number;
+	[field: string]: unknown;
 }
 export interface TeamReadinessCheck {
-    id: string;
-    state: "pass" | "fail" | "unknown";
-    reason?: string;
-    count?: number;
+	id: string;
+	state: "pass" | "fail" | "unknown";
+	reason?: string;
+	count?: number;
 }
 export type TeamWorkflowSlot = "dispatch" | "intake" | "research" | "plan" | "implement" | "remediate" | "verify" | "review" | "pr" | "done" | "canceled";
 export interface TeamWorkflowStage {
-    id: string;
-    name: string;
-    type: string;
-    position: number;
+	id: string;
+	name: string;
+	type: string;
+	position: number;
 }
 export interface TeamWorkflowRow {
-    slot: TeamWorkflowSlot;
-    linearStateId: string | null;
-    linearStateName?: string;
-    linearStateType?: string;
-    source?: "created" | "matched" | "chosen";
-    stateStillExists?: boolean;
+	slot: TeamWorkflowSlot;
+	linearStateId: string | null;
+	linearStateName?: string;
+	linearStateType?: string;
+	source?: "created" | "matched" | "chosen";
+	stateStillExists?: boolean;
 }
 export interface TeamWorkflowSummary extends TeamWorkflowReadiness {
-    mode: "mapped-existing" | "adopted-recommended" | "mixed" | null;
-    gitAutomation: "off" | "managed";
-    mappedSlots: number;
-    mappedLoadBearingSlots: number;
-    mirrored: boolean | null;
+	mode: "mapped-existing" | "adopted-recommended" | "mixed" | null;
+	gitAutomation: "off" | "managed";
+	mappedSlots: number;
+	mappedLoadBearingSlots: number;
+	mirrored: boolean | null;
 }
 export interface TeamList {
-    teams: TeamWorkflowSummary[];
-    canManage: boolean;
-    liveTeamRead: {
-        attempted: boolean;
-        error: string | null;
-        reason?: "no-teams-known" | "unnamed-team";
-    };
-    everChecked: boolean;
-    mirrorRead: boolean;
+	teams: TeamWorkflowSummary[];
+	canManage: boolean;
+	liveTeamRead: {
+		attempted: boolean;
+		error: string | null;
+		reason?: "no-teams-known" | "unnamed-team";
+	};
+	everChecked: boolean;
+	mirrorRead: boolean;
 }
 export interface TeamWorkflowView {
-    config: {
-        teamId: string;
-        mode: "mapped-existing" | "adopted-recommended" | "mixed";
-        gitAutomation: "off" | "managed";
-        workflowRev: number;
-    };
-    rows: readonly TeamWorkflowRow[];
-    stages: readonly TeamWorkflowStage[];
-    stageSource: "linear" | "mirror" | "none";
-    readiness: TeamWorkflowReadiness;
-    mappingHash: string;
-    checklist: string[] | null;
+	config: {
+		teamId: string;
+		mode: "mapped-existing" | "adopted-recommended" | "mixed";
+		gitAutomation: "off" | "managed";
+		workflowRev: number;
+	};
+	rows: readonly TeamWorkflowRow[];
+	stages: readonly TeamWorkflowStage[];
+	stageSource: "linear" | "mirror" | "none";
+	readiness: TeamWorkflowReadiness;
+	mappingHash: string;
+	checklist: string[] | null;
 }
 /** Save can commit the mapping even when its follow-up readiness recompute is unavailable. */
 export type TeamWorkflowSaveResult = Omit<TeamWorkflowView, "mappingHash" | "checklist" | "readiness"> & {
-    readiness: TeamWorkflowReadiness | null;
+	readiness: TeamWorkflowReadiness | null;
 };
 export interface TeamMappingRowInput {
-    slot: TeamWorkflowSlot;
-    linearStateId: string | null;
-    source?: "created" | "matched" | "chosen";
+	slot: TeamWorkflowSlot;
+	linearStateId: string | null;
+	source?: "created" | "matched" | "chosen";
 }
 export interface TeamMappingSaveInput {
-    team: string;
-    expectedMappingHash: string;
-    mode?: "mapped-existing" | "adopted-recommended" | "mixed";
-    gitAutomation?: "off" | "managed";
-    rows: TeamMappingRowInput[];
+	team: string;
+	expectedMappingHash: string;
+	mode?: "mapped-existing" | "adopted-recommended" | "mixed";
+	gitAutomation?: "off" | "managed";
+	rows: TeamMappingRowInput[];
 }
 export interface TeamMigrationChoice {
-    sourceStateId: string;
-    destinationStateId: string;
+	sourceStateId: string;
+	destinationStateId: string;
 }
 export interface TeamMigrationSource {
-    stateId: string;
-    name: string;
-    type: string;
-    ticketCount: number;
-    destinationStateId: string | null;
-    destinationSlot: TeamWorkflowSlot | null;
-    because: "unique-type" | "terminal-family" | "chosen" | null;
-    outcome: "ready" | "needs-a-choice" | "empty" | "moved" | "partially-moved" | "protected" | "retired-in-catalyst";
-    reason?: string;
-    retiredAt?: number;
+	stateId: string;
+	name: string;
+	type: string;
+	ticketCount: number;
+	destinationStateId: string | null;
+	destinationSlot: TeamWorkflowSlot | null;
+	because: "unique-type" | "terminal-family" | "chosen" | null;
+	outcome: "ready" | "needs-a-choice" | "empty" | "moved" | "partially-moved" | "protected" | "retired-in-catalyst";
+	reason?: string;
+	retiredAt?: number;
 }
 export interface TeamMigrationPlan {
-    teamId: string;
-    sources: readonly TeamMigrationSource[];
-    migrationHash: string;
-    overLimit: boolean;
-    issueCount: number;
-    retireLogReadable: boolean;
-    /** A false value means the server will refuse stage moves and retirement. Older servers omit it. */
-    actionsAvailable?: boolean;
+	teamId: string;
+	sources: readonly TeamMigrationSource[];
+	migrationHash: string;
+	overLimit: boolean;
+	issueCount: number;
+	retireLogReadable: boolean;
+	/** A false value means the server will refuse stage moves and retirement. Older servers omit it. */
+	actionsAvailable?: boolean;
 }
 export interface TeamAdoptResult {
-    teamId: string;
-    teamKey: string;
-    mode: "adopted-recommended" | "mapped-existing" | "mixed" | null;
-    stages: readonly {
-        name: string;
-        type: string;
-        outcome: string;
-        stateId?: string;
-        reason?: string;
-    }[];
-    planHash: string;
-    unfilledLoadBearing: readonly unknown[];
-    provenanceGaps: readonly unknown[];
-    labels: readonly {
-        name: string;
-        outcome: string;
-        reason?: string;
-    }[];
-    labelProvenanceGaps: readonly unknown[];
-    labelsNotCreated: readonly unknown[];
-    checklist?: string[];
-    readiness?: TeamWorkflowReadiness | null;
+	teamId: string;
+	teamKey: string;
+	mode: "adopted-recommended" | "mapped-existing" | "mixed" | null;
+	stages: readonly {
+		name: string;
+		type: string;
+		outcome: string;
+		stateId?: string;
+		reason?: string;
+	}[];
+	planHash: string;
+	unfilledLoadBearing: readonly unknown[];
+	provenanceGaps: readonly unknown[];
+	labels: readonly {
+		name: string;
+		outcome: string;
+		reason?: string;
+	}[];
+	labelProvenanceGaps: readonly unknown[];
+	labelsNotCreated: readonly unknown[];
+	checklist?: string[];
+	readiness?: TeamWorkflowReadiness | null;
 }
 export interface TeamUndoPreview {
-    teamId: string;
-    mode: "preview";
-    candidates: readonly {
-        stateId: string;
-        name: string | null;
-    }[];
-    undoHash: string;
+	teamId: string;
+	mode: "preview";
+	candidates: readonly {
+		stateId: string;
+		name: string | null;
+	}[];
+	undoHash: string;
 }
 export interface TeamUndoResult {
-    archived: readonly {
-        stateId: string;
-        name: string | null;
-    }[];
-    kept: readonly {
-        stateId: string;
-        name: string | null;
-        reason: string;
-    }[];
-    failed: readonly {
-        stateId: string;
-        name: string | null;
-        reason: string;
-    }[];
-    readiness: TeamWorkflowReadiness | null;
+	archived: readonly {
+		stateId: string;
+		name: string | null;
+	}[];
+	kept: readonly {
+		stateId: string;
+		name: string | null;
+		reason: string;
+	}[];
+	failed: readonly {
+		stateId: string;
+		name: string | null;
+		reason: string;
+	}[];
+	readiness: TeamWorkflowReadiness | null;
 }
 export interface TeamMigrationChunk {
-    teamId: string;
-    sources: readonly TeamMigrationSource[];
-    remaining: number;
-    migrationHash: string;
-    moved: number;
-    readiness: TeamWorkflowReadiness | null;
+	teamId: string;
+	sources: readonly TeamMigrationSource[];
+	remaining: number;
+	migrationHash: string;
+	moved: number;
+	readiness: TeamWorkflowReadiness | null;
 }
 export interface TeamMigrationRetire {
-    retired: readonly {
-        stateId: string;
-        name: string;
-    }[];
-    kept: readonly {
-        stateId: string;
-        name: string;
-        reason: string;
-    }[];
-    failed: readonly {
-        stateId: string;
-        name: string;
-        reason: string;
-    }[];
-    logGaps: readonly {
-        stateId: string;
-        reason: string;
-    }[];
-    readiness: TeamWorkflowReadiness | null;
+	retired: readonly {
+		stateId: string;
+		name: string;
+	}[];
+	kept: readonly {
+		stateId: string;
+		name: string;
+		reason: string;
+	}[];
+	failed: readonly {
+		stateId: string;
+		name: string;
+		reason: string;
+	}[];
+	logGaps: readonly {
+		stateId: string;
+		reason: string;
+	}[];
+	readiness: TeamWorkflowReadiness | null;
 }
 /** CTC-3780 — a project's WIP limit, from `GET|POST /api/v1/agent/team-wip-limit`. */
 export interface ProjectWipLimit {
-    team: {
-        id: string;
-        key: string;
-    };
-    /** The limit that applies: the project's own, else the tenant flag's, else the default (12). */
-    limit: number;
-    source: "project" | "flag" | "default";
-    /** The project's own stored value; null when it takes the flag or the default. */
-    stored: number | null;
-    /** The project's work in progress, counted as the WIP gate counts it. */
-    inProgress: number;
-    /** Epoch ms at which `inProgress` was counted. */
-    countedAt: number;
+	team: {
+		id: string;
+		key: string;
+	};
+	/** The limit that applies: the project's own, else the tenant flag's, else the default (12). */
+	limit: number;
+	source: "project" | "flag" | "default";
+	/** The project's own stored value; null when it takes the flag or the default. */
+	stored: number | null;
+	/** The project's work in progress, counted as the WIP gate counts it. */
+	inProgress: number;
+	/** Epoch ms at which `inProgress` was counted. */
+	countedAt: number;
 }
 export type ContractResult = {
-    outcome: "ok";
-    doc: TenantContract;
-    /** `cache` — served inside `maxAgeSeconds` (or on a network failure inside
-     *  `staleRefusalSeconds`); `revalidated` — a 304; `network` — a fresh 200. */
-    source: "cache" | "network" | "revalidated";
-    ageSeconds: number;
-    etag: string | null;
-    contractVersion: string;
+	outcome: "ok";
+	doc: TenantContract;
+	/** `cache` — served inside `maxAgeSeconds` (or on a network failure inside
+	 *  `staleRefusalSeconds`); `revalidated` — a 304; `network` — a fresh 200. */
+	source: "cache" | "network" | "revalidated";
+	ageSeconds: number;
+	etag: string | null;
+	contractVersion: string;
 }
 /** Past `staleRefusalSeconds` and the refresh failed: refused by name, with the failure that
  *  prevented revalidation. No document is served — there is no literal to fall back to. */
  | {
-    outcome: "stale";
-    ageSeconds: number;
-    staleRefusalSeconds: number;
-    cause: TenantClientFailure;
+	outcome: "stale";
+	ageSeconds: number;
+	staleRefusalSeconds: number;
+	cause: TenantClientFailure;
 }
 /** `offline: true` with nothing cached. */
  | {
-    outcome: "missing";
-    reason: string;
+	outcome: "missing";
+	reason: string;
 } | TenantClientFailure;
 export type ContractFailure = Exclude<ContractResult, {
-    outcome: "ok";
+	outcome: "ok";
 }>;
 export interface ContractOptions {
-    /** Revalidate even inside `maxAgeSeconds`. */
-    refresh?: boolean;
-    /** Never touch the network: the cache if any, else `missing`. */
-    offline?: boolean;
+	/** Revalidate even inside `maxAgeSeconds`. */
+	refresh?: boolean;
+	/** Never touch the network: the cache if any, else `missing`. */
+	offline?: boolean;
 }
 declare const PAGE_CURSOR: unique symbol;
 /**
@@ -353,87 +1125,115 @@ declare const PAGE_CURSOR: unique symbol;
  * is not a page position.
  */
 export type PageCursor = string & {
-    readonly [PAGE_CURSOR]: true;
+	readonly [PAGE_CURSOR]: true;
 };
 /** Admit a persisted token as a {@link PageCursor}. */
 export declare function pageCursor(token: string): PageCursor;
 /** `GET /api/v1/issues` — the facets `MirrorDO.handleIssues` reads, by their WIRE names' meaning. */
 export interface IssueListParams {
-    after?: PageCursor;
-    limit?: number;
-    teamId?: string;
-    teamKey?: string;
-    /** An unrecognised value is no narrowing server-side, never a 400 — so the type is closed here. */
-    state?: "active" | "backlog" | "done";
-    /** Linear's 1..4. */
-    priority?: 1 | 2 | 3 | 4;
-    assigneeId?: string;
-    assignee?: string;
-    cycle?: string;
-    blocked?: "ask";
-    /** `"priority"` orders the FULL scoped set by urgency; absent keeps `updated_at DESC`. */
-    sort?: "priority";
-    waitingOn?: string;
-    waitingMode?: "asks" | "all";
+	after?: PageCursor;
+	limit?: number;
+	teamId?: string;
+	teamKey?: string;
+	/** An unrecognised value is no narrowing server-side, never a 400 — so the type is closed here. */
+	state?: "active" | "backlog" | "done";
+	/** CTC-4556 — one Linear state by name (`state_name`), any case. A name no issue carries is an
+	 *  empty page, unlike an unknown `state` bucket. Needs a mirror that lists it in `scope`. */
+	stateName?: string;
+	/** Linear's 1..4. */
+	priority?: 1 | 2 | 3 | 4;
+	assigneeId?: string;
+	assignee?: string;
+	cycle?: string;
+	blocked?: "ask";
+	/** `"priority"` orders the FULL scoped set by urgency; absent keeps `updated_at DESC`. */
+	sort?: "priority";
+	waitingOn?: string;
+	waitingMode?: "asks" | "all";
 }
 export interface KeysetPageMeta {
-    /** The next page's `after`, or `null` on the last page (the header is absent there). */
-    nextCursor: PageCursor | null;
-    /** The scope's FULL row count (`X-Mirror-Total`), `null` when the server did not send it. */
-    total: number | null;
-    /** The feed head seq this page is consistent with (`X-Mirror-Cursor`). */
-    head: number | null;
+	/** The next page's `after`, or `null` on the last page (the header is absent there). */
+	nextCursor: PageCursor | null;
+	/** The scope's FULL row count (`X-Mirror-Total`), `null` when the server did not send it. */
+	total: number | null;
+	/** The feed head seq this page is consistent with (`X-Mirror-Cursor`). */
+	head: number | null;
 }
 export type IssueListResult = ({
-    outcome: "ok";
-    rows: IssueView[];
+	outcome: "ok";
+	rows: IssueView[];
+	/** CTC-4556 — the params that narrowed this page (`X-Mirror-Scope`), or `null` when the mirror
+	 *  did not say. A filter you sent that is missing here was NOT applied: the rows are wider. */
+	scope: string[] | null;
 } & KeysetPageMeta) | TenantClientFailure;
+/** CTC-1889 — the ticket's repair loop: remediate rounds, validate attempts, an active hold and the
+ *  parks that apply. The server's detail handler adds it after the view builder, and only when there
+ *  is something to show, so it is absent rather than null on a quiet ticket. Mirrors the cloud's
+ *  `TicketRepairLoopWire` (apps/mirror/src/do/ticket-repair-loop.ts). */
+export interface TicketRepairLoop {
+	remediateRounds: number;
+	validateAttempts: number;
+	hold: {
+		reason: string;
+		headSha: string | null;
+		heldAtMs: number;
+	} | null;
+	parks: ReadonlyArray<{
+		phase: string;
+		sentinel: string;
+		label: string;
+	}>;
+}
+/** `GET /api/v1/issues/:identifier`: the read-model's detail view plus the server-added fields. */
+export type IssueDetail = IssueDetailView & {
+	repairLoop?: TicketRepairLoop;
+};
 export type IssueGetResult = {
-    outcome: "ok";
-    issue: IssueDetailView;
-    head: number | null;
+	outcome: "ok";
+	issue: IssueDetail;
+	head: number | null;
 } | {
-    outcome: "not-found";
-    status: 404;
+	outcome: "not-found";
+	status: 404;
 } | TenantClientFailure;
 export interface PullListParams {
-    after?: PageCursor;
-    limit?: number;
-    /** `owner/name`. */
-    repo?: string;
-    state?: "open" | "merged";
-    blocked?: "ask";
+	after?: PageCursor;
+	limit?: number;
+	/** `owner/name`. */
+	repo?: string;
+	state?: "open" | "merged";
+	blocked?: "ask";
 }
 export type PullListResult = ({
-    outcome: "ok";
-    rows: PullView[];
-    blockedOnAskTotal: number | null;
+	outcome: "ok";
+	rows: PullView[];
+	blockedOnAskTotal: number | null;
 } & KeysetPageMeta) | TenantClientFailure;
 export type PullGetResult = {
-    outcome: "ok";
-    pull: PullDetailView;
+	outcome: "ok";
+	pull: PullDetailView;
 } | {
-    outcome: "not-found";
-    status: 404;
+	outcome: "not-found";
+	status: 404;
 } | TenantClientFailure;
 /** `GET /api/v1/projects` is offset-paged (the legacy `?cursor=` carries the offset). */
 export interface ProjectListParams {
-    limit?: number;
-    offset?: number;
+	limit?: number;
+	offset?: number;
 }
 export type ProjectListResult = {
-    outcome: "ok";
-    rows: ProjectView[];
-    head: number | null;
+	outcome: "ok";
+	rows: ProjectView[];
+	head: number | null;
 } | TenantClientFailure;
 /** `GET /api/v1/me` — how a key learns its own tenant. */
 export type MeResult = {
-    outcome: "ok";
-    account: string;
-    slug: string;
-    name: string;
-    permissions: string[] | null;
-    principal: "service" | "session";
+	outcome: "ok";
+	account: string;
+	slug: string;
+	name: string;
+	permissions: string[] | null;
+	principal: "service" | "session";
 } | TenantClientFailure;
 /** `GET /api/v1/issues/:id/execution` — the ticket's own execution/telemetry report. ⛔ The fields
  *  below are DOCUMENTED, not compiled: this repo does not depend on `catalyst-cloud`. The index
@@ -441,203 +1241,327 @@ export type MeResult = {
  *  be refused as a shape error. The tenant decides which principals may read this route (Decision 5);
  *  the client reports whatever it answers. */
 export interface TicketExecutionReport {
-    readonly identifier?: string;
-    readonly [key: string]: unknown;
+	/** The ticket the report is about. The server always sends it, under any selection. */
+	readonly ticket: string;
+	/** ⚠️ Never sent by the server; kept so code that read it still compiles. Read `ticket`. */
+	readonly identifier?: string;
+	readonly [key: string]: unknown;
 }
 export type TicketExecutionResult = {
-    outcome: "ok";
-    status: 200;
-    report: TicketExecutionReport;
+	outcome: "ok";
+	status: 200;
+	report: TicketExecutionReport;
 } | {
-    outcome: "not-found";
-    status: 404;
+	outcome: "not-found";
+	status: 404;
+} | TenantClientFailure;
+/** The projections `GET /api/v1/issues/:identifier` names. */
+export type IssueGetProjection = "status" | "brief";
+/** The projections `GET /api/v1/issues/:identifier/execution` names. */
+export type IssueExecutionProjection = "status" | "failures";
+export interface ReadSelectOptions<P extends string> {
+	/** Top-level keys only, sent joined by commas. An empty list is the server's `invalid_field`. */
+	fields?: readonly string[];
+	projection?: P;
+}
+export type IssueGetOptions = ReadSelectOptions<IssueGetProjection>;
+export type IssueExecutionOptions = ReadSelectOptions<IssueExecutionProjection>;
+/** The server refused a selection. `name` is the field or projection it did not know (`"fields"`
+ *  for an empty list); `allowed` is its catalog, so a caller can retry with a name that exists. */
+export interface ReadSelectRefusal {
+	outcome: "select-refused";
+	status: 400;
+	error: "unknown_field" | "unknown_projection" | "invalid_field";
+	name: string | null;
+	allowed: readonly string[];
+	reason: string;
+}
+/** A selected issue: any key may be absent, and the server always keeps `identifier`. */
+export type ProjectedIssueDetail = {
+	[K in keyof IssueDetail as K extends "identifier" ? never : K]?: IssueDetail[K];
+} & {
+	identifier: IssueDetail["identifier"];
+} extends infer T ? {
+	[K in keyof T]: T[K];
+} : never;
+export type IssueGetProjectedResult = {
+	outcome: "ok";
+	issue: ProjectedIssueDetail;
+	head: number | null;
+} | {
+	outcome: "not-found";
+	status: 404;
+} | ReadSelectRefusal | TenantClientFailure;
+/** The report type is already open, so a selected report needs no narrower type. */
+export type TicketExecutionProjectedResult = TicketExecutionResult | ReadSelectRefusal;
+export interface EventQueryParams {
+	ticket?: string;
+	/** One durable event type, or several (each sent as its own `type=`). */
+	type?: string | readonly string[];
+	/** The server's default is 50, its maximum 200. */
+	limit?: number;
+	/** The server's default is `desc`, newest first. */
+	order?: "asc" | "desc";
+	afterSeq?: number;
+	beforeSeq?: number;
+}
+/** Where the next page starts: the param to set and its value. `null` on the last page. */
+export interface EventQueryCursor {
+	param: "afterSeq" | "beforeSeq";
+	value: number;
+}
+/** The sequence range the cloud's index holds. An event outside it is not missing, only unindexed. */
+export interface EventIndexCoverage {
+	indexedFromSeq: number | null;
+	indexedToSeq: number | null;
+}
+/** One backbone event, verbatim: the same object a `/events/backbone` line carries. ⛔ DOCUMENTED,
+ *  not compiled beyond `sequence` and `type`, so a field the cloud adds reaches the caller. */
+export interface QueriedBackboneEvent {
+	readonly sequence: number;
+	readonly type: string;
+	readonly bodyUnavailable?: undefined;
+	readonly [key: string]: unknown;
+}
+/** An event whose body the cloud never archived (its archive write was given up on). The page
+ *  serves this stub in the event's place, never a gap, so a cursor never skips it unseen. */
+export interface QueriedEventStub {
+	readonly tenantId: string;
+	readonly sequence: number;
+	readonly eventId: string;
+	readonly type: string;
+	readonly ticket?: string;
+	readonly bodyUnavailable: true;
+	/** `archive_write_failed` today. */
+	readonly reason: string;
+}
+/** Branch on `bodyUnavailable === true`. */
+export type QueriedEvent = QueriedBackboneEvent | QueriedEventStub;
+export type EventQueryResult = {
+	outcome: "ok";
+	status: 200;
+	events: QueriedEvent[];
+	next: EventQueryCursor | null;
+	coverage: EventIndexCoverage;
+}
+/** The server has no event query route (404). Fall back; this is not "no events". */
+ | {
+	outcome: "unsupported";
+	status: 404;
+	reason: string;
+}
+/** One event is larger than a whole page (413). `next` resumes past it; `pages()` does so itself. */
+ | {
+	outcome: "too-large";
+	status: 413;
+	sequence: number;
+	maxBytes: number;
+	eventBytes: number;
+	next: EventQueryCursor;
+}
+/** The index or archive could not be read (503). Retry the same request: `resume` is the cursor
+ *  this request sent (null on a first page), and `sequence` names the event whose read failed. */
+ | {
+	outcome: "unavailable";
+	status: 503;
+	error: "archive_read_failed" | "index_unavailable" | "archive_unavailable";
+	retryable: true;
+	sequence: number | null;
+	resume: EventQueryCursor | null;
+}
+/** A `type` outside the cloud's durable registry (400). `types` lists every one it refused. */
+ | {
+	outcome: "event-type-refused";
+	status: 400;
+	types: string[];
+	reason: string;
 } | TenantClientFailure;
 /** `GET /api/v1/work-eligibility?team=` — the dispatcher's own "why is nothing moving" answer.
  *  ⛔ DOCUMENTED, not compiled — see the section note above. */
 export interface WorkEligibilityReport {
-    readonly team?: string;
-    readonly [key: string]: unknown;
+	readonly team?: string;
+	readonly [key: string]: unknown;
 }
 export type WorkEligibilityResult = {
-    outcome: "ok";
-    status: 200;
-    report: WorkEligibilityReport;
+	outcome: "ok";
+	status: 200;
+	report: WorkEligibilityReport;
 } | TenantClientFailure;
 /** `GET /api/v1/dispatch-queue/current?team=` — an ENVELOPE (`entries[]`), not a bare array. */
 export interface DispatchQueueEnvelope {
-    readonly entries: readonly Record<string, unknown>[];
-    readonly [key: string]: unknown;
+	readonly entries: readonly Record<string, unknown>[];
+	readonly [key: string]: unknown;
 }
 export type DispatchQueueResult = {
-    outcome: "ok";
-    status: 200;
-    queue: DispatchQueueEnvelope;
+	outcome: "ok";
+	status: 200;
+	queue: DispatchQueueEnvelope;
 } | TenantClientFailure;
 /** `GET /api/v1/fleet-activity/current` — a bare array of activity rows. */
 export type FleetActivityResult = {
-    outcome: "ok";
-    status: 200;
-    rows: readonly Record<string, unknown>[];
+	outcome: "ok";
+	status: 200;
+	rows: readonly Record<string, unknown>[];
 } | TenantClientFailure;
 /** `GET /api/v1/agent-roster/current` — a bare array of roster rows. */
 export type AgentRosterResult = {
-    outcome: "ok";
-    status: 200;
-    rows: readonly Record<string, unknown>[];
+	outcome: "ok";
+	status: 200;
+	rows: readonly Record<string, unknown>[];
 } | TenantClientFailure;
 /** `GET /api/v1/lease/attributions?ticket=&phase=` — both params are required (the route 400s when
  *  either is absent); the body shape is tolerant (object or array). */
 export type LeaseAttributionsResult = {
-    outcome: "ok";
-    status: 200;
-    body: unknown;
+	outcome: "ok";
+	status: 200;
+	body: unknown;
 } | TenantClientFailure;
 /** `GET /api/v1/coding-accounts` — an OBJECT carrying an `accounts` array. */
 export interface CodingAccountsReport {
-    readonly accounts: readonly Record<string, unknown>[];
-    readonly [key: string]: unknown;
+	readonly accounts: readonly Record<string, unknown>[];
+	readonly [key: string]: unknown;
 }
 export type CodingAccountsResult = {
-    outcome: "ok";
-    status: 200;
-    report: CodingAccountsReport;
+	outcome: "ok";
+	status: 200;
+	report: CodingAccountsReport;
 } | TenantClientFailure;
 /** `GET /api/v1/cycles` — the SDK's own structural copy; see the section note above. */
 export interface CycleRow {
-    readonly id?: string;
-    readonly [key: string]: unknown;
+	readonly id?: string;
+	readonly [key: string]: unknown;
 }
 export type CyclesListResult = {
-    outcome: "ok";
-    status: 200;
-    rows: readonly CycleRow[];
+	outcome: "ok";
+	status: 200;
+	rows: readonly CycleRow[];
 } | TenantClientFailure;
 /** `GET /api/v1/search?q=&limit=` — four result buckets, the SDK's own structural copy. */
 export interface SearchParams {
-    q: string;
-    limit?: number;
+	q: string;
+	limit?: number;
 }
 export interface SearchResults {
-    readonly issues?: readonly Record<string, unknown>[];
-    readonly pulls?: readonly Record<string, unknown>[];
-    readonly projects?: readonly Record<string, unknown>[];
-    readonly initiatives?: readonly Record<string, unknown>[];
-    readonly [key: string]: unknown;
+	readonly issues?: readonly Record<string, unknown>[];
+	readonly pulls?: readonly Record<string, unknown>[];
+	readonly projects?: readonly Record<string, unknown>[];
+	readonly initiatives?: readonly Record<string, unknown>[];
+	readonly [key: string]: unknown;
 }
 export type SearchResult = {
-    outcome: "ok";
-    status: 200;
-    results: SearchResults;
+	outcome: "ok";
+	status: 200;
+	results: SearchResults;
 } | TenantClientFailure;
 /** `GET /api/v1/workflow-stages` — the key-authenticated twin; its shape is never quoted anywhere in
  *  the pool (Decision 7). Tolerant: accepts `{stages, source?}` OR a bare array, normalizing both. */
 export type WorkflowStagesResult = {
-    outcome: "ok";
-    status: 200;
-    stages: readonly Record<string, unknown>[];
-    source: string | null;
+	outcome: "ok";
+	status: 200;
+	stages: readonly Record<string, unknown>[];
+	source: string | null;
 } | TenantClientFailure;
 /** `GET /api/v1/changes?since=` — the NDJSON change feed. */
 export type ChangesStreamResult = {
-    outcome: "ok";
-    status: 200;
-    head: number | null;
-    rows: AsyncGenerator<Record<string, unknown>>;
-    /**
-     * Release the feed WITHOUT draining it — cancels the response body and stops the idle deadline.
-     * Idempotent, and safe to call after the rows have been read.
-     *
-     * ⛔ A caller that reads `head` and then DISCARDS `rows` must call this (CTC-2132 validate
-     * attempt 14, code-review Finding 3): nothing else runs the generator's cleanup, so the body
-     * would stay uncancelled and its connection referenced. Draining the rows to EOF, or `break`ing
-     * out of the `for await`, already releases both — `close()` is for the caller that never starts.
-     */
-    close: () => Promise<void>;
+	outcome: "ok";
+	status: 200;
+	head: number | null;
+	rows: AsyncGenerator<Record<string, unknown>>;
+	/**
+	 * Release the feed WITHOUT draining it — cancels the response body and stops the idle deadline.
+	 * Idempotent, and safe to call after the rows have been read.
+	 *
+	 * ⛔ A caller that reads `head` and then DISCARDS `rows` must call this (CTC-2132 validate
+	 * attempt 14, code-review Finding 3): nothing else runs the generator's cleanup, so the body
+	 * would stay uncancelled and its connection referenced. Draining the rows to EOF, or `break`ing
+	 * out of the `for await`, already releases both — `close()` is for the caller that never starts.
+	 */
+	close: () => Promise<void>;
 }
 /** The tenant can no longer replay from `since` — reseed from `snapshot.head()` (or a full
  *  snapshot) rather than replaying the gap. `head` is the tenant's current head. */
  | {
-    outcome: "resync";
-    status: 409;
-    head: number | null;
-    reason: string;
+	outcome: "resync";
+	status: 409;
+	head: number | null;
+	reason: string;
 } | TenantClientFailure;
 export type ChangesListResult = {
-    outcome: "ok";
-    status: 200;
-    head: number | null;
-    rows: Record<string, unknown>[];
+	outcome: "ok";
+	status: 200;
+	head: number | null;
+	rows: Record<string, unknown>[];
 } | Extract<ChangesStreamResult, {
-    outcome: "resync";
+	outcome: "resync";
 }> | TenantClientFailure;
 /** `GET /api/v1/snapshot?head=1` — the cheap head probe (Decision 7): the shape was inferred from
  *  prose, not a quoted response body, so the parse is deliberately tolerant of three answer shapes. */
 export type SnapshotHeadResult = {
-    outcome: "ok";
-    status: 200;
-    head: number;
-    source: "header" | "body";
+	outcome: "ok";
+	status: 200;
+	head: number;
+	source: "header" | "body";
 } | {
-    outcome: "shape";
-    status: number;
-    reason: string;
+	outcome: "shape";
+	status: number;
+	reason: string;
 } | TenantClientFailure;
 export interface RawRequest {
-    method?: "GET" | "POST";
-    /** ⛔ An ABSOLUTE PATH under the client's own origin ("/api/v1/…"), never a URL. A value that is
-     *  not one is refused BEFORE the request is built: `new URL(origin + path)` does not throw on
-     *  "@host/x" — it reads the origin as USERINFO and `host` becomes the attacker's, which would send
-     *  this client's bearer credential to that host (reproduced: `new URL("https://cloud.example" +
-     *  "@evil.example/steal")` → host `evil.example`, no throw). CTC-2132. */
-    path: string;
-    query?: Record<string, string | number | undefined>;
-    headers?: Record<string, string>;
-    body?: unknown;
+	method?: "GET" | "POST";
+	/** ⛔ An ABSOLUTE PATH under the client's own origin ("/api/v1/…"), never a URL. A value that is
+	 *  not one is refused BEFORE the request is built: `new URL(origin + path)` does not throw on
+	 *  "@host/x" — it reads the origin as USERINFO and `host` becomes the attacker's, which would send
+	 *  this client's bearer credential to that host (reproduced: `new URL("https://cloud.example" +
+	 *  "@evil.example/steal")` → host `evil.example`, no throw). CTC-2132. */
+	path: string;
+	query?: Record<string, string | number | undefined>;
+	headers?: Record<string, string>;
+	body?: unknown;
 }
 export type RawRequestResult = {
-    outcome: "ok";
-    status: number;
-    json: unknown;
-    headers: Headers;
+	outcome: "ok";
+	status: number;
+	json: unknown;
+	headers: Headers;
 } | TenantClientFailure;
 /** Personal provider consent is initiated by a user credential, never an account key. */
 export type PersonalConnectionProvider = "linear" | "github";
 export type PersonalConnectionStartResult = {
-    outcome: "ok";
-    status: 200;
-    authorizationUrl: string;
-    expiresAt: number;
+	outcome: "ok";
+	status: 200;
+	authorizationUrl: string;
+	expiresAt: number;
 } | {
-    outcome: "workspace-required";
-    status: 409;
+	outcome: "workspace-required";
+	status: 409;
 } | TenantClientFailure;
 export type PersonalConnectionStatusResult = {
-    outcome: "absent";
-    status: 200;
+	outcome: "absent";
+	status: 200;
 } | {
-    outcome: "lapsed";
-    status: 200;
-    lapsedAt: number | null;
+	outcome: "lapsed";
+	status: 200;
+	lapsedAt: number | null;
 } | {
-    outcome: "connected";
-    status: 200;
-    provider: "linear";
-    linearUserId: string;
-    grantedScope: string | null;
-    updatedAt: number;
-    expiresAt: number | null;
+	outcome: "connected";
+	status: 200;
+	provider: "linear";
+	linearUserId: string;
+	grantedScope: string | null;
+	updatedAt: number;
+	expiresAt: number | null;
 } | {
-    outcome: "connected";
-    status: 200;
-    provider: "github";
-    githubUserId: string;
-    githubLogin: string;
-    updatedAt: number;
-    expiresAt: number | null;
+	outcome: "connected";
+	status: 200;
+	provider: "github";
+	githubUserId: string;
+	githubLogin: string;
+	updatedAt: number;
+	expiresAt: number | null;
 } | {
-    outcome: "unavailable";
-    status: 503;
-    provider: PersonalConnectionProvider;
+	outcome: "unavailable";
+	status: 503;
+	provider: PersonalConnectionProvider;
 } | TenantClientFailure;
 /** The routes this client wraps, by the last segment of their contract path. `delegate` (operator
  *  credential only) and `linear/read` (an origin-fresh read the replica rule discourages) are
@@ -645,311 +1569,328 @@ export type PersonalConnectionStatusResult = {
 export type AgentRouteName = "issue-state" | "issue-label" | "issue-comment" | "issue-create" | "reaction" | "attachment" | "attachments" | "session" | "ask" | "ask-accept" | "project-repositories" | "project-repositories/remove" | "portal-servers" | "portal-servers/register" | "portal-servers/remove" | "messages";
 /** The runtime twin of {@link AgentRouteName}: the list a test can walk against the contract.
  *  Kept in lockstep with the union by a compile-time equality in test/tenant-client-agent.test.ts. */
-export declare const AGENT_ROUTE_NAMES: readonly ["issue-state", "issue-label", "issue-comment", "issue-create", "reaction", "attachment", "attachments", "session", "ask", "ask-accept", "project-repositories", "project-repositories/remove", "portal-servers", "portal-servers/register", "portal-servers/remove", "messages"];
+export declare const AGENT_ROUTE_NAMES: readonly [
+	"issue-state",
+	"issue-label",
+	"issue-comment",
+	"issue-create",
+	"reaction",
+	"attachment",
+	"attachments",
+	"session",
+	"ask",
+	"ask-accept",
+	"project-repositories",
+	"project-repositories/remove",
+	"portal-servers",
+	"portal-servers/register",
+	"portal-servers/remove",
+	"messages"
+];
 /** The arms every agent call can end in BEFORE the route answers: the contract could not be served,
  *  or the tenant's contract does not list the route. */
 export type AgentCallFailure = ContractFailure | {
-    outcome: "route-unknown";
-    route: AgentRouteName;
-    routes: string[];
+	outcome: "route-unknown";
+	route: AgentRouteName;
+	routes: string[];
 } | TenantClientFailure;
 /** The proxy's shared write outcome (`ProxiedWriteResult`), on the wire with the HTTP status. The
  *  `rejected` arm is the shared {@link TenantClientFailure} one. */
 export type ProxiedWriteOutcome = {
-    outcome: "succeeded";
-    status: number;
-    attempts: number;
+	outcome: "succeeded";
+	status: number;
+	attempts: number;
 } | {
-    outcome: "exhausted";
-    status: number;
-    attempts: number;
-    lastError: string;
+	outcome: "exhausted";
+	status: number;
+	attempts: number;
+	lastError: string;
 };
 export interface IssueStateInput {
-    issueId: string;
-    /** The Linear state id — resolve it by SLOT through {@link stageIdForSlot}, never by name. */
-    stateId: string;
+	issueId: string;
+	/** The Linear state id — resolve it by SLOT through {@link stageIdForSlot}, never by name. */
+	stateId: string;
 }
 export type IssueStateResult = ProxiedWriteOutcome | AgentCallFailure;
 export interface IssueLabelInput {
-    issueId: string;
-    labelIds: string[];
-    mode: "add" | "remove";
+	issueId: string;
+	labelIds: string[];
+	mode: "add" | "remove";
 }
 export interface IssueLabelItemResult {
-    labelId: string;
-    /** `already-absent` — a remove that found nothing to remove; counts as satisfied, not as a landing. */
-    outcome: "succeeded" | "rejected" | "exhausted" | "already-absent";
-    attempts: number;
-    reason?: string;
-    lastError?: string;
+	labelId: string;
+	/** `already-absent` — a remove that found nothing to remove; counts as satisfied, not as a landing. */
+	outcome: "succeeded" | "rejected" | "exhausted" | "already-absent";
+	attempts: number;
+	reason?: string;
+	lastError?: string;
 }
 export type IssueLabelResult = {
-    outcome: "succeeded" | "failed";
-    status: number;
-    results: IssueLabelItemResult[];
+	outcome: "succeeded" | "failed";
+	status: number;
+	results: IssueLabelItemResult[];
 } | AgentCallFailure;
 export interface IssueCommentInput {
-    issueId: string;
-    body: string;
-    parentId?: string;
-    /** The agent display name (`botActor.userDisplayName`). Absent means the plain app actor. */
-    createAsUser?: string;
+	issueId: string;
+	body: string;
+	parentId?: string;
+	/** The agent display name (`botActor.userDisplayName`). Absent means the plain app actor. */
+	createAsUser?: string;
 }
 export type IssueCommentResult = ProxiedWriteOutcome | AgentCallFailure;
 export interface IssueCreateInput {
-    teamId: string;
-    title: string;
-    description?: string;
-    labelIds?: string[];
-    assigneeId?: string;
-    parentId?: string;
-    /** Linear's 0–4 scale. */
-    priority?: 0 | 1 | 2 | 3 | 4;
-    stateId?: string;
-    projectId?: string;
-    createAsUser?: string;
+	teamId: string;
+	title: string;
+	description?: string;
+	labelIds?: string[];
+	assigneeId?: string;
+	parentId?: string;
+	/** Linear's 0–4 scale. */
+	priority?: 0 | 1 | 2 | 3 | 4;
+	stateId?: string;
+	projectId?: string;
+	createAsUser?: string;
 }
 export type IssueCreateResult = {
-    outcome: "succeeded";
-    status: number;
-    attempts: number;
-    identifier: string;
-    id: string;
-    url: string | null;
+	outcome: "succeeded";
+	status: number;
+	attempts: number;
+	identifier: string;
+	id: string;
+	url: string | null;
 } | Extract<ProxiedWriteOutcome, {
-    outcome: "exhausted";
+	outcome: "exhausted";
 }> | AgentCallFailure;
 /** Exactly one of `issueId`/`commentId` — enforced by the SERVER (a 400 `rejected`); the client
  *  sends what it is given rather than carrying a second copy of the rule. */
 export interface ReactionInput {
-    issueId?: string;
-    commentId?: string;
-    /** Defaults server-side to the fleet's claim emoji. */
-    emoji?: string;
-    mode?: "add" | "remove";
-    createAsUser?: string;
+	issueId?: string;
+	commentId?: string;
+	/** Defaults server-side to the fleet's claim emoji. */
+	emoji?: string;
+	mode?: "add" | "remove";
+	createAsUser?: string;
 }
 export type ReactionResult = {
-    outcome: "succeeded";
-    status: number;
-    attempts: number;
-    reactionId: string | null;
-    alreadyPresent?: true;
-    userId?: string | null;
+	outcome: "succeeded";
+	status: number;
+	attempts: number;
+	reactionId: string | null;
+	alreadyPresent?: true;
+	userId?: string | null;
 } | {
-    outcome: "succeeded";
-    status: number;
-    attempts: number;
-    alreadyAbsent: true;
-    removed: 0;
+	outcome: "succeeded";
+	status: number;
+	attempts: number;
+	alreadyAbsent: true;
+	removed: 0;
 } | {
-    outcome: "succeeded";
-    status: number;
-    attempts: number;
-    removed: number;
+	outcome: "succeeded";
+	status: number;
+	attempts: number;
+	removed: number;
 } | Extract<ProxiedWriteOutcome, {
-    outcome: "exhausted";
+	outcome: "exhausted";
 }> | AgentCallFailure;
 export interface ProxiedAttachment {
-    id: string;
-    url: string;
-    title: string | null;
-    metadata: Record<string, unknown> | null;
+	id: string;
+	url: string;
+	title: string | null;
+	metadata: Record<string, unknown> | null;
 }
 export interface AttachmentInput {
-    issueId: string;
-    /** The upsert key — Linear dedups attachments by url. */
-    url: string;
-    title: string;
-    metadata: Record<string, unknown>;
+	issueId: string;
+	/** The upsert key — Linear dedups attachments by url. */
+	url: string;
+	title: string;
+	metadata: Record<string, unknown>;
 }
 export type AttachmentResult = (ProxiedWriteOutcome & {
-    attachment?: ProxiedAttachment;
+	attachment?: ProxiedAttachment;
 }) | AgentCallFailure;
 export type AttachmentsResult = {
-    outcome: "succeeded";
-    status: number;
-    attachments: ProxiedAttachment[];
+	outcome: "succeeded";
+	status: number;
+	attachments: ProxiedAttachment[];
 }
 /** The proxy answers an absent issue as a 404 `rejected` — "no attachments" and "no such issue"
  *  are different answers, and this arm keeps them apart. */
  | {
-    outcome: "not-found";
-    status: 404;
-    reason: string;
+	outcome: "not-found";
+	status: 404;
+	reason: string;
 } | {
-    outcome: "unauthorized-upstream";
-    status: number;
-    reason: string;
+	outcome: "unauthorized-upstream";
+	status: number;
+	reason: string;
 } | AgentCallFailure;
 export interface SessionPlanEntry {
-    content: string;
-    status: string;
+	content: string;
+	status: string;
 }
 export type SessionActivity = {
-    type: "thought" | "response";
-    body: string;
+	type: "thought" | "response";
+	body: string;
 } | {
-    type: "error";
-    body: string;
-    reasonCode?: string;
+	type: "error";
+	body: string;
+	reasonCode?: string;
 } | {
-    type: "action";
-    action: string;
-    parameter: string;
-    result?: string;
+	type: "action";
+	action: string;
+	parameter: string;
+	result?: string;
 };
 export interface SessionInput {
-    issueId: string;
-    plan?: SessionPlanEntry[];
-    activity?: SessionActivity;
-    externalUrls?: {
-        label: string;
-        url: string;
-    }[];
+	issueId: string;
+	plan?: SessionPlanEntry[];
+	activity?: SessionActivity;
+	externalUrls?: {
+		label: string;
+		url: string;
+	}[];
 }
 /** The proxy's shared write body as it appears INSIDE the session composite (no status of its own). */
 export type ProxiedWriteBody = {
-    outcome: "succeeded";
-    attempts: number;
+	outcome: "succeeded";
+	attempts: number;
 } | {
-    outcome: "exhausted";
-    attempts: number;
-    lastError: string;
+	outcome: "exhausted";
+	attempts: number;
+	lastError: string;
 } | {
-    outcome: "rejected";
-    attempts: number;
-    reason: string;
+	outcome: "rejected";
+	attempts: number;
+	reason: string;
 };
 export type EnsureSessionOutcome = {
-    outcome: "reused";
-    sessionId: string;
-    attempts: number;
+	outcome: "reused";
+	sessionId: string;
+	attempts: number;
 } | {
-    outcome: "created";
-    sessionId: string;
-    attempts: number;
+	outcome: "created";
+	sessionId: string;
+	attempts: number;
 } | {
-    outcome: "rejected";
-    attempts: number;
-    reason: string;
+	outcome: "rejected";
+	attempts: number;
+	reason: string;
 } | {
-    outcome: "exhausted";
-    attempts: number;
-    lastError: string;
+	outcome: "exhausted";
+	attempts: number;
+	lastError: string;
 };
 /** ⚠️ The status is the WORST of the sub-outcomes (rejected 400 > exhausted 502 > 200); read
  *  `session`/`plan`/`externalUrls`/`activity` individually — a 502 here can carry a reused session. */
 export type SessionResult = {
-    outcome: "ok";
-    status: number;
-    session: EnsureSessionOutcome;
-    plan?: ProxiedWriteBody;
-    externalUrls?: ProxiedWriteBody;
-    activity?: ProxiedWriteBody;
+	outcome: "ok";
+	status: number;
+	session: EnsureSessionOutcome;
+	plan?: ProxiedWriteBody;
+	externalUrls?: ProxiedWriteBody;
+	activity?: ProxiedWriteBody;
 } | AgentCallFailure;
 export interface AskInput {
-    teamId: string;
-    title: string;
-    context: string;
-    defaultIfSilent: string;
-    /** The idempotency key — a re-raise under the same key answers the existing ask. */
-    askKey: string;
-    options?: string[];
-    blocks?: string[];
-    nothingToBlock?: true;
-    target?: {
-        membershipId: string;
-    } | {
-        email: string;
-    };
+	teamId: string;
+	title: string;
+	context: string;
+	defaultIfSilent: string;
+	/** The idempotency key — a re-raise under the same key answers the existing ask. */
+	askKey: string;
+	options?: string[];
+	blocks?: string[];
+	nothingToBlock?: true;
+	target?: {
+		membershipId: string;
+	} | {
+		email: string;
+	};
 }
 export type AskResult = {
-    outcome: "created";
-    status: number;
-    askId: string;
-    identifier: string;
-    existing?: true;
+	outcome: "created";
+	status: number;
+	askId: string;
+	identifier: string;
+	existing?: true;
 } | {
-    outcome: "created-but-relations-partial";
-    status: number;
-    askId: string;
-    identifier: string;
-    failedBlocks: string[];
-    existing?: true;
+	outcome: "created-but-relations-partial";
+	status: number;
+	askId: string;
+	identifier: string;
+	failedBlocks: string[];
+	existing?: true;
 } | {
-    outcome: "exhausted";
-    status: number;
-    lastError: string;
+	outcome: "exhausted";
+	status: number;
+	lastError: string;
 } | AgentCallFailure;
 export interface AskAcceptInput {
-    askIssueId: string;
-    answerCommentId: string;
-    /** A single line of at most 64 characters. */
-    acceptedByRole?: string;
+	askIssueId: string;
+	answerCommentId: string;
+	/** A single line of at most 64 characters. */
+	acceptedByRole?: string;
 }
 export type AskAcceptRefusal = "not-an-ask" | "issue-not-mirrored" | "already-resolved" | "answer-comment-not-mirrored" | "answer-comment-not-on-ask" | "answer-comment-not-wake-target" | "answer-comment-is-agent" | "not-assignee" | "already-in-flight" | "readiness-needs-tap" | "ask-has-no-team";
 export type AskAcceptResult = {
-    outcome: "recorded";
-    status: number;
-    askIdentifier: string;
-    decisionSummary: string;
-    failedBlockedComments: string[];
-    resume: unknown[];
-    unblock?: unknown;
+	outcome: "recorded";
+	status: number;
+	askIdentifier: string;
+	decisionSummary: string;
+	failedBlockedComments: string[];
+	resume: unknown[];
+	unblock?: unknown;
 } | {
-    outcome: "refused";
-    status: number;
-    reason: AskAcceptRefusal;
+	outcome: "refused";
+	status: number;
+	reason: AskAcceptRefusal;
 } | {
-    outcome: "record-failed";
-    status: number;
-    reason: string;
-    resume?: unknown[];
+	outcome: "record-failed";
+	status: number;
+	reason: string;
+	resume?: unknown[];
 } | AgentCallFailure;
 /** Both project-repository routes take the same address: a repository plus ONE of project /
  *  teamKey / teamId. This route is NOT accounted against the write budget
  *  (`takesWriteBudgetUnit: false`); it is gated on an admin/owner personal key or an
  *  organization key carrying `mirror:write`. */
 export interface ProjectRepositoryInput {
-    /** `owner/name`, sent VERBATIM. ⚠️ The cloud validates the trimmed halves but stores what it
-     *  was sent (CTC-2503 re-validation) — trim before calling if the value came from a human. */
-    repository: string;
-    project?: string;
-    teamKey?: string;
-    teamId?: string;
+	/** `owner/name`, sent VERBATIM. ⚠️ The cloud validates the trimmed halves but stores what it
+	 *  was sent (CTC-2503 re-validation) — trim before calling if the value came from a human. */
+	repository: string;
+	project?: string;
+	teamKey?: string;
+	teamId?: string;
 }
 export interface RegisteredProjectRepository {
-    repoId: string;
-    owner: string;
-    name: string;
-    /** Present when the `repos` row carries one (e.g. `"paused"`). */
-    status?: string;
+	repoId: string;
+	owner: string;
+	name: string;
+	/** Present when the `repos` row carries one (e.g. `"paused"`). */
+	status?: string;
 }
 export type ProjectRepositoryRegisterResult = {
-    outcome: "registered";
-    status: number;
-    registered: RegisteredProjectRepository;
-    created: boolean;
-    linked: boolean;
+	outcome: "registered";
+	status: number;
+	registered: RegisteredProjectRepository;
+	created: boolean;
+	linked: boolean;
 }
 /** The project is absent, archived, or another tenant's — one answer for all three. */
  | {
-    outcome: "not-found";
-    status: 404;
-    reason: string;
+	outcome: "not-found";
+	status: 404;
+	reason: string;
 } | AgentCallFailure;
 export type ProjectRepositoryRemoveResult = 
 /** `removed: false` is idempotent success, not a failure — there was nothing to unlink. */
 {
-    outcome: "removed";
-    status: number;
-    removed: boolean;
+	outcome: "removed";
+	status: number;
+	removed: boolean;
 } | {
-    outcome: "not-found";
-    status: 404;
-    reason: string;
+	outcome: "not-found";
+	status: 404;
+	reason: string;
 } | AgentCallFailure;
 /** CTC-3254 — `POST …/agent/messages` (CTC-3121): a message to the agent running a ticket's current
  *  phase, which it reads as one more user turn when its current turn ends. The SENDER comes from the
@@ -958,77 +1899,77 @@ export type ProjectRepositoryRemoveResult =
  *  message). To address a roster `agentId`, resolve it to the ticket its worker runs (the roster
  *  entry's `scope`) before calling; the cloud does not resolve roster ids. */
 export interface AgentMessageInput {
-    /** The ticket identifier, e.g. `CTC-42`. */
-    ticket: string;
-    /** At most 4096 bytes of UTF-8. */
-    body: string;
-    /** Defaults to `note` on the server. */
-    kind?: "note" | "question" | "answer";
-    /** The id of the earlier message this one answers. */
-    re?: string;
+	/** The ticket identifier, e.g. `CTC-42`. */
+	ticket: string;
+	/** At most 4096 bytes of UTF-8. */
+	body: string;
+	/** Defaults to `note` on the server. */
+	kind?: "note" | "question" | "answer";
+	/** The id of the earlier message this one answers. */
+	re?: string;
 }
 export type AgentMessageResult = 
 /** The running session reads it at its next turn boundary. */
 {
-    outcome: "accepted";
-    status: number;
-    messageId: string;
-    ticket: string;
-    delivery: "next-turn";
+	outcome: "accepted";
+	status: number;
+	messageId: string;
+	ticket: string;
+	delivery: "next-turn";
 }
 /** It waits for the ticket's next phase, and why: nothing is running, the run has no channel for it
  *  mid-phase, or the run is not reading messages. */
  | {
-    outcome: "accepted";
-    status: number;
-    messageId: string;
-    ticket: string;
-    delivery: "next-phase";
-    reason: "no-live-phase" | "run-cannot-receive" | "run-not-reading";
+	outcome: "accepted";
+	status: number;
+	messageId: string;
+	ticket: string;
+	delivery: "next-phase";
+	reason: "no-live-phase" | "run-cannot-receive" | "run-not-reading";
 }
 /** The ticket already holds the per-ticket cap of pending messages (20). */
  | {
-    outcome: "refused";
-    status: 409;
-    reason: "too_many_pending";
+	outcome: "refused";
+	status: 409;
+	reason: "too_many_pending";
 } | AgentCallFailure;
 /** Upstream auth references only account vault names, never credential values. */
 export type PortalServerAuth = {
-    kind: "none";
+	kind: "none";
 } | {
-    kind: "bearer";
-    secretName: string;
+	kind: "bearer";
+	secretName: string;
 } | {
-    kind: "headers";
-    headers: {
-        name: string;
-        secretName: string;
-    }[];
+	kind: "headers";
+	headers: {
+		name: string;
+		secretName: string;
+	}[];
 };
 export interface PortalServerRegisterInput {
-    name: string;
-    url: string;
-    auth: PortalServerAuth;
+	name: string;
+	url: string;
+	auth: PortalServerAuth;
 }
 export interface PortalServer extends PortalServerRegisterInput {
-    id: string;
-    /** Custom servers stay pending until a server-side account admin approves them. */
-    status: "ready" | "pending" | "pending_egress_guard";
+	id: string;
+	/** Custom servers stay pending until a server-side account admin approves them. */
+	status: "ready" | "pending" | "pending_egress_guard";
 }
 export type PortalServerRegisterResult = {
-    outcome: "registered";
-    status: number;
-    server: PortalServer;
+	outcome: "registered";
+	status: number;
+	server: PortalServer;
 } | AgentCallFailure;
 export type PortalServersResult = {
-    outcome: "ok";
-    status: number;
-    servers: PortalServer[];
+	outcome: "ok";
+	status: number;
+	servers: PortalServer[];
 } | AgentCallFailure;
 export type PortalServerRemoveResult = {
-    outcome: "removed";
-    status: number;
-    removed: boolean;
+	outcome: "removed";
+	status: number;
+	removed: boolean;
 } | AgentCallFailure;
 /** The next-page keyset token on `/issues` and `/pulls`; ABSENT on the last page. */
 export declare const NEXT_CURSOR_HEADER = "X-Mirror-Next-Cursor";
@@ -1036,6 +1977,8 @@ export declare const NEXT_CURSOR_HEADER = "X-Mirror-Next-Cursor";
 export declare const HEAD_SEQ_HEADER = "X-Mirror-Cursor";
 /** The scope's full row count on `/issues` and `/pulls` — the page can never report what lies past it. */
 export declare const TOTAL_HEADER = "X-Mirror-Total";
+/** `/issues` only (CTC-4556): the params that narrowed the page, comma-separated. */
+export declare const SCOPE_HEADER = "X-Mirror-Scope";
 /** `/pulls` only: the "N of M blocked on an ask" numerator. */
 export declare const BLOCKED_ON_ASK_TOTAL_HEADER = "X-Mirror-Blocked-On-Ask-Total";
 /** The contract route's own version header, equal to the body's `contractVersion`. */
@@ -1050,135 +1993,147 @@ export declare function normalizeBaseUrl(baseUrl: string): string;
 export declare function createTenantClient(opts: TenantClientOptions): TenantClient;
 /** The client. See {@link createTenantClient}. */
 export interface TenantClient {
-    /** Personal bearer team setup. The key's tenant and admin role are enforced by the cloud. */
-    teamWorkflow: {
-        teams(): Promise<TeamWorkflowResult<TeamList>>;
-        get(team: string): Promise<TeamWorkflowResult<TeamWorkflowView>>;
-        check(team: string): Promise<TeamWorkflowResult<{
-            readiness: TeamWorkflowReadiness;
-            ask: Record<string, unknown>;
-        }>>;
-        save(input: TeamMappingSaveInput): Promise<TeamWorkflowResult<TeamWorkflowSaveResult>>;
-        adoptPreview(team: string): Promise<TeamWorkflowResult<TeamAdoptResult>>;
-        adoptApply(team: string, planHash: string): Promise<TeamWorkflowResult<TeamAdoptResult>>;
-        undoPreview(team: string): Promise<TeamWorkflowResult<TeamUndoPreview>>;
-        undoApply(team: string, undoHash: string): Promise<TeamWorkflowResult<TeamUndoResult>>;
-        migratePreview(team: string, choices?: TeamMigrationChoice[]): Promise<TeamWorkflowResult<{
-            preview: TeamMigrationPlan;
-        }>>;
-        migrateChunk(team: string, migrationHash: string, choices?: TeamMigrationChoice[]): Promise<TeamWorkflowResult<TeamMigrationChunk>>;
-        migrateRetire(team: string, migrationHash: string, choices?: TeamMigrationChoice[]): Promise<TeamWorkflowResult<TeamMigrationRetire>>;
-    };
-    /** A project's WIP limit (CTC-3780). Any active member reads; personal key or CLI login. */
-    getProjectWipLimit(team: string): Promise<TeamWorkflowResult<ProjectWipLimit>>;
-    /** Sets it, clamped by the cloud to 0..9999; `null` returns the project to the default. Admin or
-     *  owner only: anyone else gets `outcome: "forbidden"`. Answers the value after the write. */
-    setProjectWipLimit(team: string, limit: number | null): Promise<TeamWorkflowResult<ProjectWipLimit>>;
-    /** Self-service unmatched identity recovery. Personal credentials only. */
-    linearIdentity: {
-        get(): Promise<LinearIdentityResult>;
-        /** Records only the authenticated member's choice. Automatically resolved identities refuse. */
-        set(linearUserId: string): Promise<LinearIdentityResult>;
-    };
-    /** The tenant's fact document, cached per its own `cache` policy. */
-    contract(opts?: ContractOptions): Promise<ContractResult>;
-    /** `GET /api/v1/me` — the account this key belongs to. */
-    me(): Promise<MeResult>;
-    /** The generic authed-request escape hatch (CTC-2132) — for a route nobody enumerated. `path` MUST
-     *  be an absolute path under this client's own origin; see {@link RawRequest}. */
-    request(req: RawRequest): Promise<RawRequestResult>;
-    /** User-scoped GitHub and Linear OAuth grants. Use a personal key or device-login credential. */
-    personalConnections: {
-        /** Returns a short lived URL to open in the user's browser. Does not perform consent. */
-        start(provider: PersonalConnectionProvider): Promise<PersonalConnectionStartResult>;
-        /** A provider outage is `unavailable`, never `absent`. */
-        status(provider: PersonalConnectionProvider): Promise<PersonalConnectionStatusResult>;
-    };
-    issues: {
-        /** `GET /api/v1/issues` — keyset-paged; follow `nextCursor` until it is `null`. */
-        list(params?: IssueListParams): Promise<IssueListResult>;
-        /** `GET /api/v1/issues/:identifier`. */
-        get(identifier: string): Promise<IssueGetResult>;
-        /** `GET /api/v1/issues/:id/execution` — the ticket's own execution/telemetry report. */
-        execution(identifier: string): Promise<TicketExecutionResult>;
-    };
-    pulls: {
-        list(params?: PullListParams): Promise<PullListResult>;
-        /** `GET /api/v1/pulls/:id` — `id` is the PR's GitHub node id. */
-        get(nodeId: string): Promise<PullGetResult>;
-    };
-    projects: {
-        list(params?: ProjectListParams): Promise<ProjectListResult>;
-    };
-    cycles: {
-        /** `GET /api/v1/cycles` — the SDK's own structural row type; see {@link CycleRow}. */
-        list(): Promise<CyclesListResult>;
-    };
-    /** `GET /api/v1/search?q=&limit=`. */
-    search(params: SearchParams): Promise<SearchResult>;
-    /** `GET /api/v1/workflow-stages` — tolerant of a `{stages,source?}` envelope or a bare array. */
-    workflowStages(): Promise<WorkflowStagesResult>;
-    changes: {
-        /** `GET /api/v1/changes?since=` — NDJSON. ⛔ The returned generator MAY THROW mid-iteration; use
-         *  `list` for the nothing-throws, buffered alternative. */
-        stream(params: {
-            since: number | "head";
-            signal?: AbortSignal;
-        }): Promise<ChangesStreamResult>;
-        /** The same feed, buffered — never throws; a mid-stream fault comes back as the `network` arm. */
-        list(params: {
-            since: number | "head";
-            signal?: AbortSignal;
-        }): Promise<ChangesListResult>;
-    };
-    snapshot: {
-        /** `GET /api/v1/snapshot?head=1` — the cheap head probe; never falls back to a full snapshot. */
-        head(): Promise<SnapshotHeadResult>;
-    };
-    /** The diagnosis / telemetry reads (CTC-2132, M2 addendum) — a customer delegate agent's own
-     *  "why is nothing moving" / "what is my fleet doing" answers. */
-    diagnostics: {
-        workEligibility(params?: {
-            team?: string;
-        }): Promise<WorkEligibilityResult>;
-        dispatchQueue(params?: {
-            team?: string;
-        }): Promise<DispatchQueueResult>;
-        fleetActivity(params?: {
-            account?: string;
-        }): Promise<FleetActivityResult>;
-        agentRoster(): Promise<AgentRosterResult>;
-        leaseAttributions(params: {
-            ticket: string;
-            phase: string;
-        }): Promise<LeaseAttributionsResult>;
-        codingAccounts(): Promise<CodingAccountsResult>;
-    };
-    /** The `/api/v1/agent/*` proxy — every tenant write as the app actor, path from `routes[]`. */
-    agent: {
-        issueState(input: IssueStateInput): Promise<IssueStateResult>;
-        issueLabel(input: IssueLabelInput): Promise<IssueLabelResult>;
-        issueComment(input: IssueCommentInput): Promise<IssueCommentResult>;
-        issueCreate(input: IssueCreateInput): Promise<IssueCreateResult>;
-        reaction(input: ReactionInput): Promise<ReactionResult>;
-        attachment(input: AttachmentInput): Promise<AttachmentResult>;
-        /** `GET …/attachments?issueId=` — the soft-CAS read-back; no write-budget unit. */
-        attachments(input: {
-            issueId: string;
-        }): Promise<AttachmentsResult>;
-        session(input: SessionInput): Promise<SessionResult>;
-        ask(input: AskInput): Promise<AskResult>;
-        askAccept(input: AskAcceptInput): Promise<AskAcceptResult>;
-        portalServerRegister(input: PortalServerRegisterInput): Promise<PortalServerRegisterResult>;
-        portalServers(): Promise<PortalServersResult>;
-        portalServerRemove(input: {
-            name: string;
-        }): Promise<PortalServerRemoveResult>;
-        projectRepositoryRegister(input: ProjectRepositoryInput): Promise<ProjectRepositoryRegisterResult>;
-        projectRepositoryRemove(input: ProjectRepositoryInput): Promise<ProjectRepositoryRemoveResult>;
-        /** `POST …/agent/messages` — send a ticket's running agent a message it reads at its next turn. */
-        message(input: AgentMessageInput): Promise<AgentMessageResult>;
-    };
-}
+	/** Personal bearer team setup. The key's tenant and admin role are enforced by the cloud. */
+	teamWorkflow: {
+		teams(): Promise<TeamWorkflowResult<TeamList>>;
+		get(team: string): Promise<TeamWorkflowResult<TeamWorkflowView>>;
+		check(team: string): Promise<TeamWorkflowResult<{
+			readiness: TeamWorkflowReadiness;
+			ask: Record<string, unknown>;
+		}>>;
+		save(input: TeamMappingSaveInput): Promise<TeamWorkflowResult<TeamWorkflowSaveResult>>;
+		adoptPreview(team: string): Promise<TeamWorkflowResult<TeamAdoptResult>>;
+		adoptApply(team: string, planHash: string): Promise<TeamWorkflowResult<TeamAdoptResult>>;
+		undoPreview(team: string): Promise<TeamWorkflowResult<TeamUndoPreview>>;
+		undoApply(team: string, undoHash: string): Promise<TeamWorkflowResult<TeamUndoResult>>;
+		migratePreview(team: string, choices?: TeamMigrationChoice[]): Promise<TeamWorkflowResult<{
+			preview: TeamMigrationPlan;
+		}>>;
+		migrateChunk(team: string, migrationHash: string, choices?: TeamMigrationChoice[]): Promise<TeamWorkflowResult<TeamMigrationChunk>>;
+		migrateRetire(team: string, migrationHash: string, choices?: TeamMigrationChoice[]): Promise<TeamWorkflowResult<TeamMigrationRetire>>;
+	};
+	/** A project's WIP limit (CTC-3780). Any active member reads; personal key or CLI login. */
+	getProjectWipLimit(team: string): Promise<TeamWorkflowResult<ProjectWipLimit>>;
+	/** Sets it, clamped by the cloud to 0..9999; `null` returns the project to the default. Admin or
+	 *  owner only: anyone else gets `outcome: "forbidden"`. Answers the value after the write. */
+	setProjectWipLimit(team: string, limit: number | null): Promise<TeamWorkflowResult<ProjectWipLimit>>;
+	/** Self-service unmatched identity recovery. Personal credentials only. */
+	linearIdentity: {
+		get(): Promise<LinearIdentityResult>;
+		/** Records only the authenticated member's choice. Automatically resolved identities refuse. */
+		set(linearUserId: string): Promise<LinearIdentityResult>;
+	};
+	/** The tenant's fact document, cached per its own `cache` policy. */
+	contract(opts?: ContractOptions): Promise<ContractResult>;
+	/** `GET /api/v1/me` — the account this key belongs to. */
+	me(): Promise<MeResult>;
+	/** The generic authed-request escape hatch (CTC-2132) — for a route nobody enumerated. `path` MUST
+	 *  be an absolute path under this client's own origin; see {@link RawRequest}. */
+	request(req: RawRequest): Promise<RawRequestResult>;
+	/** User-scoped GitHub and Linear OAuth grants. Use a personal key or device-login credential. */
+	personalConnections: {
+		/** Returns a short lived URL to open in the user's browser. Does not perform consent. */
+		start(provider: PersonalConnectionProvider): Promise<PersonalConnectionStartResult>;
+		/** A provider outage is `unavailable`, never `absent`. */
+		status(provider: PersonalConnectionProvider): Promise<PersonalConnectionStatusResult>;
+	};
+	issues: {
+		/** `GET /api/v1/issues` — keyset-paged; follow `nextCursor` until it is `null`. */
+		list(params?: IssueListParams): Promise<IssueListResult>;
+		/** `GET /api/v1/issues/:identifier`. */
+		get(identifier: string): Promise<IssueGetResult>;
+		/** The same read, asking for only some top-level keys (CTC-4549). The issue is partial; a name
+		 *  the server does not know is `select-refused` with its catalog. */
+		get(identifier: string, select: IssueGetOptions): Promise<IssueGetProjectedResult>;
+		/** `GET /api/v1/issues/:id/execution` — the ticket's own execution/telemetry report. */
+		execution(identifier: string): Promise<TicketExecutionResult>;
+		/** The same report, asking for only some top-level keys (CTC-4549). */
+		execution(identifier: string, select: IssueExecutionOptions): Promise<TicketExecutionProjectedResult>;
+	};
+	pulls: {
+		list(params?: PullListParams): Promise<PullListResult>;
+		/** `GET /api/v1/pulls/:id` — `id` is the PR's GitHub node id. */
+		get(nodeId: string): Promise<PullGetResult>;
+	};
+	projects: {
+		list(params?: ProjectListParams): Promise<ProjectListResult>;
+	};
+	cycles: {
+		/** `GET /api/v1/cycles` — the SDK's own structural row type; see {@link CycleRow}. */
+		list(): Promise<CyclesListResult>;
+	};
+	/** `GET /api/v1/search?q=&limit=`. */
+	search(params: SearchParams): Promise<SearchResult>;
+	/** `GET /api/v1/workflow-stages` — tolerant of a `{stages,source?}` envelope or a bare array. */
+	workflowStages(): Promise<WorkflowStagesResult>;
+	changes: {
+		/** `GET /api/v1/changes?since=` — NDJSON. ⛔ The returned generator MAY THROW mid-iteration; use
+		 *  `list` for the nothing-throws, buffered alternative. */
+		stream(params: {
+			since: number | "head";
+			signal?: AbortSignal;
+		}): Promise<ChangesStreamResult>;
+		/** The same feed, buffered — never throws; a mid-stream fault comes back as the `network` arm. */
+		list(params: {
+			since: number | "head";
+			signal?: AbortSignal;
+		}): Promise<ChangesListResult>;
+	};
+	/** A tenant's event history from the cloud (CTC-4549). An older server answers `unsupported`. */
+	events: {
+		/** `GET /api/v1/events/query` — one page, filtered by ticket and type. */
+		query(params?: EventQueryParams): Promise<EventQueryResult>;
+		/** Every page, following `next`. Never throws; a failed page is yielded and ends the walk. */
+		pages(params?: EventQueryParams): AsyncGenerator<EventQueryResult, void, undefined>;
+	};
+	snapshot: {
+		/** `GET /api/v1/snapshot?head=1` — the cheap head probe; never falls back to a full snapshot. */
+		head(): Promise<SnapshotHeadResult>;
+	};
+	/** The diagnosis / telemetry reads (CTC-2132, M2 addendum) — a customer delegate agent's own
+	 *  "why is nothing moving" / "what is my fleet doing" answers. */
+	diagnostics: {
+		workEligibility(params?: {
+			team?: string;
+		}): Promise<WorkEligibilityResult>;
+		dispatchQueue(params?: {
+			team?: string;
+		}): Promise<DispatchQueueResult>;
+		fleetActivity(params?: {
+			account?: string;
+		}): Promise<FleetActivityResult>;
+		agentRoster(): Promise<AgentRosterResult>;
+		leaseAttributions(params: {
+			ticket: string;
+			phase: string;
+		}): Promise<LeaseAttributionsResult>;
+		codingAccounts(): Promise<CodingAccountsResult>;
+	};
+	/** The `/api/v1/agent/*` proxy — every tenant write as the app actor, path from `routes[]`. */
+	agent: {
+		issueState(input: IssueStateInput): Promise<IssueStateResult>;
+		issueLabel(input: IssueLabelInput): Promise<IssueLabelResult>;
+		issueComment(input: IssueCommentInput): Promise<IssueCommentResult>;
+		issueCreate(input: IssueCreateInput): Promise<IssueCreateResult>;
+		reaction(input: ReactionInput): Promise<ReactionResult>;
+		attachment(input: AttachmentInput): Promise<AttachmentResult>;
+		/** `GET …/attachments?issueId=` — the soft-CAS read-back; no write-budget unit. */
+		attachments(input: {
+			issueId: string;
+		}): Promise<AttachmentsResult>;
+		session(input: SessionInput): Promise<SessionResult>;
+		ask(input: AskInput): Promise<AskResult>;
+		askAccept(input: AskAcceptInput): Promise<AskAcceptResult>;
+		portalServerRegister(input: PortalServerRegisterInput): Promise<PortalServerRegisterResult>;
+		portalServers(): Promise<PortalServersResult>;
+		portalServerRemove(input: {
+			name: string;
+		}): Promise<PortalServerRemoveResult>;
+		projectRepositoryRegister(input: ProjectRepositoryInput): Promise<ProjectRepositoryRegisterResult>;
+		projectRepositoryRemove(input: ProjectRepositoryInput): Promise<ProjectRepositoryRemoveResult>;
+		/** `POST …/agent/messages` — send a ticket's running agent a message it reads at its next turn. */
+		message(input: AgentMessageInput): Promise<AgentMessageResult>;
+	};
+}
+
 export {};
-//# sourceMappingURL=tenant-client.d.ts.map