wicked-crew-api-types 0.149.0 → 0.170.0

package/index.d.ts

@@ -353,6 +353,49 @@ export interface HealthCapabilities {
    * ABSENT on an older daemon: read as `false` and hide the switch.
    */
   powerMode?: boolean | undefined;
+  /**
+   * (api-types 0.156.0, DES-VOICE) Voice mode's routes are served: `GET /voice/status`, `POST|DELETE /voice/model`,
+   * `POST /voice/transcribe` and `GET|PUT /voice/dashboard`. Whether transcription can run NOW (the engine and
+   * the model are on this machine) is {@link VoiceStatus.ready}. ABSENT on an older daemon: read as `false`.
+   */
+  voice?: boolean;
+  /**
+   * (api-types 0.168.0) `GET /workflows/catalog` is served: the categorised workflow catalog with the
+   * requesting operator's usage ({@link WorkflowCatalogResponse}). ABSENT on an older daemon: read as `false`.
+   */
+  workflowCatalog?: boolean;
+  /**
+   * (api-types 0.169.0, DES-CHAT-ARTIFACTS-001 §14) What a chat can do with artifacts, one flag per operation, each
+   * true only once its slice ships. `context`: `ChatMessageBody.context` is accepted ({@link ChatMessageContext}),
+   * `POST /chats {seedFromArtifact}` is served, and each turn's seats get the open artifact, the runs the person names
+   * and the ids they may use, recorded per turn as a `context` transcript record. `proposals` (api-types 0.170.0,
+   * slice A2): a seat's `wicked-make` block becomes a crew-resolved proposal card answered by a person. The operations
+   * (`create`, `refine`, `theme`, `demo`) are later slices and are `false` until then (all `true` with `stub: true` in
+   * the test configuration). ABSENT on an older daemon: read every flag as `false`, and send no `context` (the message
+   * body is strict there, so the field would be refused).
+   */
+  chatArtifacts?: ChatArtifactsCapabilities;
+}
+
+/** {@link HealthCapabilities.chatArtifacts} (api-types 0.169.0). */
+export interface ChatArtifactsCapabilities {
+  context: boolean;
+  /**
+   * (api-types 0.170.0, slice A2) A seat's `wicked-make` block becomes a crew-resolved proposal ({@link ArtifactProposal},
+   * transcript kinds `proposal` / `proposal_accepting` / `proposal_decided`, `/ws` {@link ChatProposalFrame}) and
+   * `POST /chats/:id/proposals/:pid` answers it. Seats are told only about the operations below that are `true`, and
+   * the resolver and the accept route refuse the others, so with every operation `false` no card is made.
+   */
+  proposals: boolean;
+  create: boolean;
+  refine: boolean;
+  theme: boolean;
+  demo: boolean;
+  /**
+   * (api-types 0.170.0) The daemon runs the chat-artifacts TEST configuration (DES §13 A2): every operation resolves,
+   * and Go on a proposal records a stub dispatch and starts NOTHING. A skin says so on the card. ABSENT otherwise.
+   */
+  stub?: true;
 }
 
 // ── A run's working document (program DES-POWER-MODE §8.3, §9; api-types 0.148.0) ──────────────────
@@ -360,10 +403,12 @@ export interface HealthCapabilities {
 /** The working document's sections, in order. */
 export type WorkingDocSectionId = 'goal' | 'approach' | 'decisions' | 'constraints' | 'questions' | 'next';
 
-/** Who wrote a version: a person (the operator), a plugin's own generated lines, or crew (the first version). */
+/** Who wrote a version: a person (the operator), a plugin's own generated lines, the power orchestrator's own notes
+ *  (`agent`, id `agent:<seat>`: Approach and Decisions only, never a steer), or crew (the first version). */
 export type WorkingDocAuthor =
   | { kind: 'human'; id: string }
   | { kind: 'plugin'; id: string }
+  | { kind: 'agent'; id: string }
   | { kind: 'system'; id: 'crew' };
 
 /** One version of the working document, as crew attributed it. */
@@ -401,6 +446,9 @@ export interface WorkingDocSteer {
   error: string | null;
   supersededBy?: string | null;
   renewals?: number;
+  /** (0.161.0, DES-VOICE) The person said the edit and confirmed it on screen: the thread says "You (by voice)".
+   *  ABSENT on a typed edit (and on an older daemon). It grants nothing. */
+  input?: 'voice';
 }
 
 /** `GET /runs/:id/working-doc` (and the body of `POST /runs/:id/working-doc`). */
@@ -412,15 +460,23 @@ export interface WorkingDocView {
   labels: Record<WorkingDocSectionId, string>;
   trail: WorkingDocTrailEntry[];
   steers: WorkingDocSteer[];
+  /** (0.151.0) `true` when crew itself writes the document's event-derived lines (Decisions answered, Open questions,
+   *  Next) from the run's own log, as `plugin:wicked-phase-report@…`: a host plugin then writes none of its own and
+   *  only renders and takes a person's edits. ABSENT on an older daemon — read as `false` (the plugin keeps writing). */
+  eventLines?: boolean;
 }
 
 /** `POST /runs/:id/working-doc/versions`. `author: 'operator'` only from a person; `author: 'plugin'` writes only the
- *  plugin's own section (`decisions`). 409 `{head}` when the document moved since `base`. */
+ *  plugin's own lines, under `decisions`, `questions` and `next` (never `goal`, `approach` or `constraints`: 403). A
+ *  plugin's write never steers, in any section (`steer` is null). 409 `{head}` when the document moved since `base`. */
 export interface ProposeWorkingDocRequest {
   base: number;
   sections: Partial<Record<WorkingDocSectionId, string>>;
   author: 'operator' | 'plugin';
   plugin?: { id: string; version: string };
+  /** (0.161.0, DES-VOICE) The person said this edit and confirmed it on screen. On `author: 'operator'` only (400
+   *  otherwise); kept on the steer ({@link WorkingDocSteer.input}) and the `run.steered.doc` audit line. */
+  input?: 'voice';
 }
 
 export interface ProposeWorkingDocResponse {
@@ -776,7 +832,46 @@ export type PowerActivityEvent = {
   subject: string | null;
 };
 
+/** `/ws` frame: a seat's tool call started or finished, live from its stream as it happens (bus
+ *  `wicked.run.tool.started` / `wicked.run.tool.finished`). Sent for claude, codex (`exec --json` items) and pi
+ *  (`--mode json` tool executions); at most 24 frames per 2 s and 4000 per attempt, and a call shown starting is
+ *  always shown finishing. `target` is a repo-relative path, a search, or a command with secrets cut, at most 160
+ *  characters. (0.151.0) `state: 'working'` (bus `wicked.run.tool.working`) is a quiet seat's heartbeat, any seat,
+ *  copilot included: after 15 s with no frame, one per 15 s while it stays quiet, `id` `working-<attempt>` (update one
+ *  row), `kind: 'working'`, `tool` the seat, `target` `last output N s ago`, `durationMs` that silence. */
+export type ToolActivityEvent = {
+  type: 'toolActivity';
+  session: string;
+  ord: number;
+  attempt: number;
+  at: number;
+  id: string;
+  state: 'started' | 'finished' | 'working';
+  kind: 'read' | 'search' | 'run' | 'test' | 'edit' | 'write' | 'skill' | 'task' | 'other' | 'working';
+  tool: string;
+  target: string | null;
+  ok: boolean | null;
+  durationMs: number | null;
+};
+
+/** `/ws` frame: new working notes from the power orchestrator's stream (bus `wicked.run.notes.recorded`): its
+ *  approach when stated or restated, and each new decision with its reason. Crew writes them into the run's working
+ *  document as `agent:<seat>`; they never steer. */
+export type PowerWorkingNotesEvent = {
+  type: 'powerWorkingNotes';
+  session: string;
+  ord: number;
+  attempt: number;
+  turn: number;
+  seat: string;
+  at: number;
+  approach: string | null;
+  decisions: Array<{ text: string; why: string | null }>;
+};
+
 export type PowerEvent =
+  | ToolActivityEvent
+  | PowerWorkingNotesEvent
   | PowerActivityEvent
   | PowerIntakePlannedEvent
   | RigorRescoredEvent
@@ -796,6 +891,10 @@ export type RunBusType =
   | 'wicked.run.handoff.stepped'
   | 'wicked.run.power.toggled'
   | 'wicked.run.activity.recorded'
+  | 'wicked.run.tool.started'
+  | 'wicked.run.tool.finished'
+  | 'wicked.run.tool.working'
+  | 'wicked.run.notes.recorded'
   | 'wicked.run.unit.started'
   | 'wicked.run.unit.finished'
   | 'wicked.run.checks.evaluated'
@@ -2366,6 +2465,20 @@ export interface GateDecision {
    * `POST /runs/:id/resume` or `/reassign`.
    */
   ord?: number;
+  /**
+   * (api-types 0.156.0, DES-VOICE) The person answered by voice: studio matched the spoken words to this
+   * answer, showed it on screen and the person confirmed it, then the usual undo window ran. Recorded on the
+   * `gate.decided` audit line and {@link DecidedGate.input}; it grants nothing a typed answer does not.
+   */
+  input?: 'voice';
+  /**
+   * (api-types 0.160.0, program DES-LEARN §3.1) On a steering-author propose gate: the drafted rule ids
+   * (`SteeringDraftResponse.rules[].id`) the person keeps. Only those land; the rest are declined
+   * (`SteeringLandingResult.declinedIds`, audited `governance.steering.declined`). Absent = every drafted
+   * rule lands. With a plain approve only (400 otherwise); **409** `no_draft` on a gate with no readable
+   * draft, **409** `draft_changed` when an id is not in the draft as it reads now (the gate stays open).
+   */
+  keepRules?: string[];
 }
 
 /**
@@ -2441,6 +2554,8 @@ export interface CoreEvent {
   seat?: string;
   /** `elicitationCreated`: an ordered set of valid responses; `null` / absent = free-text. */
   options?: string[] | null;
+  /** `elicitationCreated` (api-types 0.158.0): a multi-select's bounds (`propType: "array"`). Absent otherwise. */
+  multi?: ElicitationMulti;
   /**
    * `elicitationCreated` (C3; wicked-core-ts >= 0.7.35, api-types 0.83.0): the index into `options`
    * of the option the PRODUCER of the options recommends (the field's JSON Schema `default`).
@@ -2465,6 +2580,13 @@ export interface CoreEvent {
   /** `awaitingHuman{gateKind: 'consent'}` (core#820): why no write targets are listed (no dry run
    *  ran before the gate, or it printed no plan); the gate is then a plain approve / reject. */
   writeTargetsMissing?: string;
+  /**
+   * `awaitingHuman{gateKind: 'repeat'}` (api-types 0.163.0, domain-graph-3): a loop step's ask —
+   * its command's progress line ("Mapping wicked-crew · 3% → 23% · target 80% · page 21 · budget
+   * reached …"). The ask's answers ride `choices` (`consent:<id>`…, `reject` = stop, the run ends
+   * and what it did is kept), `choiceLabels` and `recommended`, as on a consent gate.
+   */
+  repeatLine?: string;
   /** PTY terminal frames (`terminalOpened`/`terminalOutput`/`terminalExited`): the terminal id. */
   id?: string;
   /**
@@ -2872,6 +2994,24 @@ export interface CliUsageEvent {
   costUsd: number | null;
 }
 
+/**
+ * (0.155.0) `/ws` frame (and logged with the run): a working seat's running token TOTAL for one unit attempt, live from
+ * its own stream (wicked-core: claude per assistant message, pi per `message_end`, codex per `turn.completed`). Fresh +
+ * cache input, as {@link CliUsageEvent} counts it; sent when it changed, at most one per 3 s. `costUsd` only where the
+ * seat's stream states one (pi), else `null`. The attempt's `cliUsage` at its end stays the record.
+ */
+export interface UsageProgressEvent {
+  type: 'usageProgress';
+  session: string;
+  ord: number;
+  attempt: number;
+  /** Unix ms. */
+  at: number;
+  inputTokens: number;
+  outputTokens: number;
+  costUsd: number | null;
+}
+
 /** §3 B4 — the data files a unit's CLI touched. */
 export interface DataUsedEvent {
   type: 'dataUsed';
@@ -4039,6 +4179,23 @@ export interface WorkflowSelectedEvent {
   unitCount: number;
 }
 
+/**
+ * (api-types 0.163.0, domain-graph-3) A loop step sent the run back for another pass: every unit
+ * from `fromOrd` through `ord` was re-armed at a fresh attempt and the run goes on from `fromOrd`.
+ * `pass` counts the passes the loop has sent back (1 after the first); `line` is the step's own
+ * progress line ("Mapping wicked-crew · 3% → 12% → 19% · target 80% · page 4 · about 2 h left"),
+ * possibly empty. One per loop rewind: a page that reaches the target, or stops at a budget ask
+ * (whose `awaitingHuman.repeatLine` carries the line), emits none.
+ */
+export type StepRepeatedEvent = {
+  type: 'stepRepeated';
+  session: string;
+  ord: number;
+  fromOrd: number;
+  pass: number;
+  line: string;
+};
+
 /** P2 — a human approved a gate with an amendment text that was injected into the unit's description
  *  before re-dispatch. Fires after the amendment is persisted, before Resumed. Only emitted when
  *  the amendment text is non-empty. The canonical record for the HITL paper trail. */
@@ -4223,6 +4380,28 @@ export interface WorkerMessageInjectedEvent {
   message: string;
   /** `"all"` or the cli_key that was targeted. */
   target: string;
+  /** (0.161.0, DES-VOICE) Stamped by crew when the note was sent with {@link InjectMessageRequest.input} `voice`
+   *  (on `/ws` and `GET /runs/:id/events`; also on the `workerMessageQueued` frame). Crew remembers spoken notes in
+   *  memory, so one sent before a daemon restart reads as typed here; its `run.injected` audit line keeps it. */
+  input?: 'voice';
+}
+
+/** `POST /runs/:id/cancel` (0.161.0): the body is optional; a bodiless cancel is unchanged. */
+export interface CancelRunRequest {
+  /** Why the person stopped it (≤ 2000 characters), said or typed: kept on the `run.cancelled` audit line. */
+  reason?: string;
+  /** (DES-VOICE) The person said the stop and confirmed it on screen. A person's only (403 otherwise). */
+  input?: 'voice';
+}
+
+/** `POST /runs/:id/inject`: an operator note into the run's active worker(s). */
+export interface InjectMessageRequest {
+  message: string;
+  /** `"all"` (the default) or a CLI key. */
+  target?: string;
+  /** (0.161.0, DES-VOICE) The person said this note and confirmed it on screen. A person's only (403 for a worker or
+   *  plugin bearer); kept on the `run.injected` audit line and stamped on the note's frames. Grants nothing. */
+  input?: 'voice';
 }
 
 /** A unit was stopped and re-dispatched to a different CLI (or re-routed via council). */
@@ -4484,6 +4663,91 @@ export interface SteeringLandingResult {
   alreadyLanded?: boolean;
   /** Present iff `outcome: "failed"` — the loud, operator-readable reason. */
   error?: string;
+  /** (api-types 0.160.0) The drafted rules the approve's `keepRules` left out: never landed. */
+  declinedIds?: string[];
+}
+
+/**
+ * `GET /governance/steering/author/:runId/draft` (api-types 0.160.0, program DES-LEARN §3.1): a
+ * steering-author run's drafted rules, normalized exactly as the landing lands them. `ready` is true once
+ * the propose step has run and the run waits at a gate; until then `rules` may be empty. 404 for an
+ * unknown run or one that is not steering-author (`code: "not_steering_author"`).
+ */
+export interface SteeringDraftResponse {
+  runId: string;
+  ready: boolean;
+  rules: ConformanceRule[];
+  source?: SteeringProposalSource;
+}
+
+// ── Personality (api-types 0.160.0, program DES-LEARN §3.3) ──────────────────────────────────────
+
+/** 0 = the left word, 2 = the right word: length short..thorough, warmth plain..warm, pushback goes
+ *  along..challenges, initiative asks first..just starts. */
+export type PersonaDial = 0 | 1 | 2;
+export type PersonaHabit = 'says-unchecked' | 'tables' | 'cites' | 'names';
+
+/** `PUT /persona`'s `persona`: how the orchestrator talks. Tone only: never read by a gate, review, QE or rule. */
+export interface PersonaInput {
+  /** 1..40 characters. */
+  name: string;
+  /** `#rrggbb`. */
+  colour: string;
+  dials: { length: PersonaDial; warmth: PersonaDial; pushback: PersonaDial; initiative: PersonaDial };
+  habits: PersonaHabit[];
+  /** At most 500 characters, about tone. */
+  notes?: string;
+}
+
+export interface Persona extends PersonaInput {
+  /** 1 on the first save of a scope, one more on each save. */
+  version: number;
+  /** Unix ms. */
+  updatedAt: number;
+}
+
+/** `user`, or `project:<id>` for one project's override. */
+export type PersonaScope = 'user' | `project:${string}`;
+
+/** `GET /persona`: the person's own, every project override, and the voice block each adds to what a chat
+ *  seat is told (the project's override, else the person's, rides every chat's scope statement). */
+export interface PersonaResponse {
+  user: Persona | null;
+  projects: Record<string, Persona>;
+  voice: { user: string | null; projects: Record<string, string> };
+}
+
+/** `PUT /persona` body: a person only (403 otherwise); 404 for an unknown project. */
+export interface PersonaPutBody {
+  scope: PersonaScope;
+  persona: PersonaInput;
+}
+
+export interface PersonaSaved {
+  scope: PersonaScope;
+  persona: Persona;
+  voice: string;
+}
+
+/** `DELETE /persona?scope=project:<id>`: removes a project's override (a person only). */
+export interface PersonaRemoved {
+  removed: true;
+  scope: PersonaScope;
+}
+
+// ── First run (api-types 0.160.0, program DES-LEARN §4) ──────────────────────────────────────────
+
+/** `GET /setup/known` (operator trust): what studio shows before it asks. A fact that cannot be read is
+ *  `null` or empty, never guessed. */
+export interface SetupKnown {
+  /** The global git identity; null when neither name nor email is set. */
+  git: { name: string | null; email: string | null } | null;
+  /** Tracked source files by language across the registered repositories (`git ls-files`), at most 6. */
+  languages: Array<{ name: string; files: number; share: number }>;
+  filesCounted: number;
+  /** Git checkouts one level under the home's code folders and the registered repositories' folders,
+   *  not registered yet (at most 24). `path` is absolute: register with `POST /repos {name, rootPath}`. */
+  nearby: Array<{ name: string; path: string }>;
 }
 
 // ── Skills — the daemon-owned garden plugin root, published as immutable snapshots (api-types 0.28.0) ──
@@ -6227,6 +6491,7 @@ export interface RepoGraphResponse {
   finding?: RepoFinding;
 }
 
+/** One row of `GET /repos/:id/git-history` (`?limit=` 1..500, default 20; newest first). */
 export interface GitCommit {
   sha: string;
   shortSha: string;
@@ -6279,6 +6544,29 @@ export interface SystemSettings {
    * Exported as `WICKED_COUNCIL_SPAWN_STAGGER_MS`, read per council. Absent = the default.
    */
   councilSpawnStaggerMs?: number;
+  /**
+   * (api-types 0.159.0, operator ruling 2026-10-31) The requirements graph's minimum coverage:
+   * `minCoveragePct`, a whole percentage 1..100, default 80. A repository's requirements graph is
+   * built, and shown labelled with its share, once REAL requirements (0.164.0: placeholders never
+   * count) reach this share of its behaviour-bearing product code; below it the
+   * `domain-extraction` run says "N% real requirements, minimum M%" and keeps the mapping for the
+   * next run. The daemon exports it as
+   * `WICKED_REQUIREMENTS_MIN_COVERAGE_PCT` at boot and on every change. Absent = the default.
+   */
+  requirementsGraph?: {
+    minCoveragePct?: number;
+    /**
+     * (api-types 0.163.0, domain-graph-3) A domain-extraction run maps page after page until the
+     * target; its budget per grant — `maxPages` (1..200, default 20) or `maxMinutes` (1..1440,
+     * default 240), whichever is spent first — ends in an ask: map more, lower the target for the
+     * repository, or stop. `pageSize` (50..2000, default 500) is how many behaviours one page
+     * maps. Exported as `WICKED_DOMAIN_MAX_PAGES` / `WICKED_DOMAIN_MAX_MINUTES` /
+     * `WICKED_DOMAIN_PAGE_SIZE`. Absent = the defaults.
+     */
+    maxPages?: number;
+    maxMinutes?: number;
+    pageSize?: number;
+  };
   /*
    * There is NO skills setting (skills keystone, api-types 0.28.0). The daemon-owned skills root is
    * `<state home>/skills` — the directory holding `manifest.json`, `baseline/<hash>/`, `effective/`,
@@ -6472,6 +6760,74 @@ export interface SettingsResponse {
 }
 
 // ── Requirements management (server-side search + overrides; crew api/requirements.ts) ──
+/**
+ * (0.159.0, operator ruling 2026-10-31 "validation by duplication") How many INDEPENDENT sources in
+ * the repository support a requirement beyond the extractor's own statement, as `wicked-core
+ * domain-graph` computed it: distinct callers (`callSites`), tests, docs that name it, and extractor
+ * seats beyond the first. `validated` at 2 or more; otherwise `unconfirmed`, and `why` says what is
+ * missing — show `why.text` on the item. `why.code` is one of `unindexed_file` (a file the code index
+ * skipped names it, so its callers there are not counted), `dead_code`, `config_only`,
+ * `single_caller`, `test_only`, `doc_only`, `extractors_only`.
+ */
+export interface RequirementCorroboration {
+  status: 'validated' | 'unconfirmed';
+  sources: number;
+  callSites: number;
+  tests: number;
+  docs: number;
+  extraExtractors: number;
+  why?: { code: string; text: string };
+}
+
+/**
+ * (0.164.0, operator decision 2026-11-01, wicked-core#1233) How much of a repository's product code
+ * is REAL requirements, and the minimum the graph is held to (`SystemSettings.requirementsGraph
+ * .minCoveragePct`): label it "23% real requirements · 4397 placeholders · minimum 80%".
+ *
+ * - `realPct` is the one number the minimum is checked against: `floor(real * 100 /
+ *   behaviorBearing)`, floored so it never reads above the minimum it was compared to; 100 when
+ *   `behaviorBearing` is 0 (nothing in product code to map). `real + placeholders + unmapped ===
+ *   behaviorBearing`; a label that breaks either is not sent.
+ * - `real`: behaviours resolved to a stated, sourced business rule.
+ * - `placeholders`: behaviours carrying only a risk-flagged placeholder (an empty statement, a rule
+ *   under the confidence threshold, one written unconfirmed). Shown in the graph as unconfirmed,
+ *   NEVER counted toward the minimum.
+ * - `unmapped`: behaviours with nothing recorded yet.
+ * - `behaviorBearing`: the denominator, product code only. `notProduct` counts the behaviour-kind
+ *   nodes left out because their file is a test, data, manifest or document file.
+ *
+ * Replaces 0.159.0's `mappedPct` / `mapped` / `resolved`, which counted placeholders as mapped (a
+ * repository with 3 real requirements and 117 placeholders read "100% mapped").
+ */
+export interface RequirementsCoverage {
+  realPct: number;
+  minPct: number;
+  behaviorBearing: number;
+  real: number;
+  placeholders: number;
+  unmapped: number;
+  notProduct: number;
+}
+
+/**
+ * (0.165.0) The graph a requirements page lists, as it was built. When `behind`, the header (`coverage`, the store
+ * now) does not count what the list holds: say so. When this `coverage.real` is below the header's: "2,202 real
+ * requirements mapped since the last graph build; build the graph to list them". With `coverage` null: "built
+ * before real requirements were counted; build the graph to list the N real requirements mapped now". Otherwise
+ * (only another count moved, or `real` fell): "the repository changed since this graph was built".
+ */
+export interface RequirementsGraphBuild {
+  /** The build's generation in the store (1 = the first build; 0 = a graph persisted before the engine kept a
+   *  build record). */
+  generation: number;
+  /** The label the build persisted; `null` when it carried none or an older engine's `mapped_pct` label. */
+  coverage: RequirementsCoverage | null;
+  /** True when any count of the build's label differs from the page's `coverage` (or the label is null), or
+   *  (0.167.0) when the engine judged every listed row and the counted rows' verdicts are not the header's real and
+   *  placeholders. False says the counts agree, not that every statement is unchanged. */
+  behind: boolean;
+}
+
 export interface RequirementSummary {
   key: string;
   domain: string;
@@ -6483,6 +6839,20 @@ export interface RequirementSummary {
   risk: boolean;
   riskSource: 'operator' | 'data' | null;
   edited: boolean;
+  /** (0.159.0) Validated or unconfirmed (with why). `null` on a graph built before the field;
+   *  ABSENT from an older daemon. */
+  corroboration?: RequirementCorroboration | null;
+  /** (0.166.0) The engine would not count it a real requirement (a validated requirement, or a business rule at or
+   *  above the resolve threshold, 0.75): a placeholder, unconfirmed whatever its corroboration says. (0.167.0) The
+   *  engine's own verdict when it gives one, else read off the document. ABSENT from an older daemon. */
+  placeholder?: boolean;
+  /** (0.167.0) The coverage share does not count this row, and why: its unit is not a behaviour (`structural`, a
+   *  TypeScript shape or signature), is outside product code (`not_product`), or is no longer indexed (`unindexed`).
+   *  Such a row is neither a real requirement nor a placeholder of the header's (its `placeholder` says only whether
+   *  a rule was stated there), sorts after them, and carries
+   *  `corroboration: null` (a type has no callers; "dead code" would be wrong). `null` when it counts or the engine
+   *  does not say; ABSENT from an older daemon. */
+  uncounted?: 'structural' | 'not_product' | 'unindexed' | null;
 }
 
 export interface RequirementDetail extends RequirementSummary {
@@ -6508,12 +6878,55 @@ export interface RequirementsPage {
   source: 'store' | 'artifact';
   /**
    * Keys in `requirements_overrides.json` that matched NO requirement in the corpus. Operator
-   * edits are keyed by SymbolId (store) or `domain::reqId` (artifact); an estate id-scheme
-   * migration re-mints method/field SymbolIds, so overrides keyed by the old ids stop matching and
-   * would otherwise vanish silently. Non-zero means edits exist that no row is showing — re-run
-   * the annotation workflow, then re-apply or delete the stale keys.
+   * edits are keyed by `domain::reqId` whatever the source (older daemons serving `'store'` keyed
+   * them by SymbolId). The engine keeps a requirement's id across builds, so a key stops matching
+   * when its requirement is retired or its domain regrouped. Non-zero means edits exist that no
+   * row is showing — re-apply or delete the stale keys.
    */
   orphanedOverrides?: number;
+  /** (0.159.0; real requirements since 0.164.0) The graph's coverage label; `null` when absent, an
+   *  older engine's `mapped_pct` label, or one its counts do not support; ABSENT from an older
+   *  daemon. */
+  coverage?: RequirementsCoverage | null;
+  /**
+   * (0.165.0) Which build the rows are. The list is the last graph BUILD; `coverage` counts the store NOW,
+   * which moves on when a run maps more without building (stopped at its repeat ask, or below the minimum,
+   * where the build refuses). `null` when the engine does not say; ABSENT from an older daemon.
+   */
+  graphBuild?: RequirementsGraphBuild | null;
+  /** (0.159.0) How many requirements of the whole corpus are validated / unconfirmed. (0.167.0) Rows the share does
+   *  not count are in neither. */
+  corroboration?: { validated: number; unconfirmed: number };
+  /**
+   * (0.167.0) Rows of the whole corpus the coverage share does not count (items with `uncounted`), split stated /
+   * placeholder: why the list holds more rows than the header. When this is not `null` and `graphBuild.behind` is
+   * false, the rows that are neither placeholders nor uncounted number exactly `coverage.real`. `null` when the engine
+   * did not judge every row (an older engine, a build before it recorded each row's unit, a malformed verdict): those
+   * rows are read off the document, and there is no such claim. ABSENT from an older daemon.
+   */
+  uncounted?: { stated: number; placeholders: number } | null;
+  /** (0.167.0) How many rows of the whole corpus are in each category, so a client can leave out an empty filter.
+   *  ABSENT from an older daemon. */
+  categories?: { functional: number; configData: number };
+}
+
+/**
+ * `GET /repos/:id/requirements` 404 when the repository's `requirements_graph.json` has not been
+ * generated (0.154.0). A state, not a refusal: `code` is the discriminator a client matches on, and
+ * `workflow` names the preset that generates the graph (its last step runs `wicked-core domain-graph`).
+ * Any other 404 on the route (an unknown repo) carries no `code`.
+ */
+export interface RequirementsNotGenerated {
+  error: string;
+  code: 'notGenerated';
+  workflow: string;
+  /**
+   * (api-types 0.163.0, domain-graph-3; real requirements since 0.164.0) How far the repository
+   * is, against its target ("23% real requirements · 4397 placeholders · target 80%"): present
+   * when the repository has a store to count.
+   * `minPct` is the target in force (the repository's own when lowered, else the daemon's).
+   */
+  coverage?: RequirementsCoverage;
 }
 
 export interface RequirementPatch {
@@ -6571,14 +6984,130 @@ export interface ElicitationInfo {
   ord?: number;
   attempt?: number;
   seat?: string;
+  /**
+   * (api-types 0.158.0, guided asks) The person may pick SEVERAL of `options`: at least `min`, at most `max`
+   * (both always set, `1 <= min <= max <= options.length`). Answer it with `content: {values}`; the engine records
+   * the picks as a JSON array in `options` order. ABSENT on a single-choice or free-text question and on an older
+   * daemon.
+   */
+  multi?: ElicitationMulti;
   receivedAt: string;
 }
 
-/** `POST /runs/:id/elicitation` body. `content` is required for accept, absent otherwise. */
+/** (api-types 0.158.0) How many of a multi-select elicitation's options an answer picks. */
+export interface ElicitationMulti {
+  min: number;
+  max: number;
+}
+
+/**
+ * `POST /runs/:id/elicitation` body. `content` is required for accept, absent otherwise: `{response}` answers a
+ * free-text or single-choice question (one of `options`); `{values}` (api-types 0.158.0) answers a multi-select one
+ * ({@link ElicitationInfo.multi}): distinct entries of `options`, `min..=max` of them. Crew answers 400 to `values` on
+ * a question that is not multi-select, and to `response` on one that is.
+ */
 export interface ElicitationResponse {
   elicitationId: string;
   action: 'accept' | 'decline' | 'cancel';
-  content?: { response: string };
+  content?: { response: string } | { values: string[] };
+}
+
+// ── Guided asks (api-types 0.158.0; design DES-GUIDED-CHAT) ─────────────────────────────────────────────────────
+//
+// ONE typed shape for every question a person answers inline: an engine gate, a seat's or MCP server's elicitation,
+// a power-mode pause, a plugin's proposal, a studio setup step. It is a RENDERING contract: the wire shapes that
+// exist stay as they are and map onto it (GateInfo.choices + recommended + gateKind → `choose`; ElicitationInfo
+// options/multi → `choose` / `pick` / `text`), and every answer still goes through its host's own route
+// (`POST /runs/:id/gate` with a GateDecision, `POST /runs/:id/elicitation`, …). Governance is the host's: an ask
+// never widens who may answer, and a gate's ask is always `answeredBy: 'person'`.
+
+/** The six ways a person answers. */
+export type AskKind =
+  /** Yes / no (two options; picking one is the answer). */
+  | 'confirm'
+  /** Choose one of 2..n options. */
+  | 'choose'
+  /** Pick several (`multi` bounds). */
+  | 'pick'
+  /** Short text. */
+  | 'text'
+  /** A point on a scale (named steps, or a number range). */
+  | 'scale'
+  /** Confirm, with a required reason (a danger move: stop, reject, skip QE, override). */
+  | 'confirm_reason';
+
+/** Which route answers the ask. */
+export type AskHost = 'gate' | 'elicitation' | 'chat' | 'learn' | 'plugin' | 'power';
+
+/** One option of a `confirm` / `choose` / `pick` / `confirm_reason` ask. */
+export interface AskOption {
+  /** Stable within the ask. */
+  id: string;
+  /** What the person reads (and the voice vocabulary). */
+  label: string;
+  /** One line under the label. */
+  sub?: string;
+  /** What happens if this option is taken, shown while it is hovered or selected ("If you choose this: …"). */
+  consequence?: string;
+  /** The wire answer: a gate action token, an elicitation option, a pause decision. */
+  token: string;
+  tone?: 'primary' | 'neutral' | 'danger';
+  /** The engine's (or producer's) recommendation: marked, and preselected unless the host says otherwise. */
+  recommended?: boolean;
+  /** Taking it asks for a reason first (kept with the record). */
+  needsReason?: boolean;
+  /** Shown but not choosable; the string says why ("Frozen: nothing merges there"). */
+  disabled?: string;
+  /** A small tag ("default", "current release"). */
+  meta?: string;
+}
+
+/** A named-step scale, or a number range. */
+export type AskScale =
+  | { steps: string[]; consequences?: string[] }
+  | { min: number; max: number; step: number; labels: [string, string] };
+
+export interface Ask {
+  /** Gate: `<runId>:<ord>`; elicitation: its `elicitationId`; otherwise the host's own id. */
+  id: string;
+  host: AskHost;
+  /** Who asks, in words ("Codex asks", "The engine asks"). */
+  from: { kind: 'engine' | 'seat' | 'plugin' | 'studio'; id: string; label: string };
+  /** One sentence, a question. */
+  prompt: string;
+  /** One line under the question. */
+  detail?: string;
+  kind: AskKind;
+  options?: AskOption[];
+  /** `pick`: how many (defaults: 1 and every option). */
+  multi?: { min?: number; max?: number };
+  /** Preselected: an option id (`choose` / `confirm`), option ids (`pick`), a step index or value (`scale`). */
+  default?: string | string[] | number;
+  scale?: AskScale;
+  text?: { placeholder?: string; maxChars?: number; optional?: boolean };
+  /** A follow-up shown in the same card once the first part is answered (pick the steps, then say what). */
+  then?: Ask;
+  /** A gate is always `'person'`. */
+  answeredBy: 'person' | 'any';
+  /** The answer waits this long, with Undo, before it is sent (a gate: 10 000). */
+  undoMs?: number;
+  /** The answered line: `{label}`, `{labels}` and `{text}` are filled ("You chose: {label}"). */
+  record: string;
+}
+
+/** What a person answered: the host turns it into its own wire body. */
+export interface AskAnswer {
+  askId: string;
+  /** `confirm` / `choose` / `confirm_reason`: the option taken. */
+  option?: string;
+  /** `pick`: the options picked, in the ask's order. */
+  options?: string[];
+  /** `text`, and a `then` text. */
+  text?: string;
+  /** `scale`: the step index or value. */
+  value?: number;
+  /** A `needsReason` option's reason. */
+  reason?: string;
 }
 
 // ── Inventory claims (wicked-crew#721) — whether each enumerating step's list is complete ──
@@ -6611,6 +7140,116 @@ export interface RunInventoryUnit {
   claims: InventoryClaim[];
 }
 
+/**
+ * `GET /runs/:id/learnings` — what a run proposed to the approve queue (run learnings, crew src/learnings).
+ * Every learning is a `memory` proposal attributed to the run (`provenance.run_id`); nothing is used until a
+ * person approves it on the Memory page. `distilling` is true while the run's distil seat (one cheap seat
+ * that did not build the run) is still reading its evidence.
+ */
+export interface RunLearningsResponse {
+  runId: string;
+  proposed: number;
+  pending: number;
+  approved: number;
+  rejected: number;
+  distilling: boolean;
+  items: Array<{
+    /** The proposal id (approve or reject it through `/proposals/:id/*`). */
+    id: string;
+    state: string;
+    /** `gotcha` | `decision` | `pattern` | `steering`, as filed. */
+    capture: string | null;
+    content: string;
+    /** Who worded it: `crew` (from the run's record) or the distil seat. */
+    agent: string | null;
+    /** Unix seconds. */
+    createdAt: number | null;
+  }>;
+}
+
+/** (0.155.0) The in-flight check's verdict on a working step. */
+export type UnitInspectVerdict = 'progressing' | 'looping' | 'stuck' | 'wasteful';
+/** (0.155.0) The one action a check recommends; the person chooses, nothing is done for them. */
+export type UnitInspectAction = 'let_run' | 'steer' | 'stop';
+
+/** (0.155.0) Crew's own deterministic reading of a working step's newest attempt (crew src/inspect/reading.ts). */
+export interface UnitInspectReading {
+  ord: number;
+  attempt: number;
+  startedAt: number | null;
+  elapsedMs: number | null;
+  calls: number;
+  openCalls: Array<{ tool: string; target: string | null; forMs: number }>;
+  byKind: Record<string, number>;
+  edits: Array<{ path: string; count: number }>;
+  said: { deltas: number; chars: number; lastAt: number | null; newest: string | null };
+  usage: { inputTokens: number; outputTokens: number; costUsd: number | null; source: 'live' | 'final' } | null;
+  lastSignAt: number | null;
+  verdict: UnitInspectVerdict;
+  evidence: string[];
+  doing: string | null;
+  action: UnitInspectAction;
+  note: string | null;
+}
+
+/**
+ * (0.155.0) One "Is this going well?" check on a working step (`POST /runs/:id/units/:ord/inspect`). A seat that is not
+ * the step's own reads the step's record (one read-only `inspect-unit` run, bounded by time and budget) and answers;
+ * when none can, or it fails, times out or reaches its budget, `source: 'crew'` and `why` says so and the answer is
+ * crew's own reading. It never steers, stops or edits the run it looks at.
+ */
+export interface UnitInspection {
+  id: string;
+  runId: string;
+  ord: number;
+  attempt: number;
+  state: 'checking' | 'done';
+  /** The actor id who asked. */
+  requestedBy: string;
+  /** Unix ms. */
+  requestedAt: number;
+  finishedAt: number | null;
+  /** The step's own seat. */
+  workerSeat: string | null;
+  /** The seat that checked (never the step's own); null when none could. */
+  seat: string | null;
+  /** The check's own run (workflow `inspect-unit`); null when none was launched. */
+  checkRunId: string | null;
+  source: 'seat' | 'crew' | null;
+  why: string | null;
+  verdict: UnitInspectVerdict | null;
+  /** What the step is doing, one sentence. */
+  doing: string | null;
+  /** Roughly how far along it is (the seat's estimate), one sentence. */
+  progress: string | null;
+  evidence: string[];
+  action: UnitInspectAction | null;
+  /** For `action: 'steer'`: the note it suggests sending the step's seat (the person may edit it before sending). */
+  note: string | null;
+  reading: UnitInspectReading;
+  /** What the check itself spent, when its seat reported it. */
+  cost: { inputTokens: number; outputTokens: number; costUsd: number | null } | null;
+}
+
+/** (0.155.0) `POST /runs/:id/units/:ord/inspect` → 202. 403 for anyone but a human operator; 409 `not_working` when the
+ *  step is not working now. A check already running on the step is answered as it is. */
+export interface UnitInspectionResponse {
+  inspection: UnitInspection;
+}
+
+/** (0.155.0) `GET /runs/:id/units/:ord/inspections`: the step's checks, newest first. */
+export interface UnitInspectionsResponse {
+  inspections: UnitInspection[];
+}
+
+/** (0.155.0) `/ws` frame: a check started, its budget moved, or it answered. */
+export interface UnitInspectionEvent {
+  type: 'unitInspection';
+  session: string;
+  ord: number;
+  inspection: UnitInspection;
+}
+
 /**
  * `GET /runs/:id/inventory` (404 for an unknown run). `complete` is true only when at least one
  * unit claimed an inventory, every claim is `full` and every finished unit's output was readable;
@@ -6693,6 +7332,115 @@ export interface PresetResponse {
   preset: Preset;
 }
 
+// ── The workflow catalog (api-types 0.168.0, lane wf-catalog) ───────────────────────────────────
+
+/** A catalog category id. `yours` is listed only when the operator has saved presets. */
+export type WorkflowCatalogCategoryId = 'create' | 'resolve' | 'analyze' | 'test' | 'more' | 'yours';
+
+/** One category of the catalog, in display order, with its ordered subcategories (`[]` for `more` and `yours`). */
+export interface WorkflowCatalogCategory {
+  id: WorkflowCatalogCategoryId;
+  title: string;
+  /** One line under the heading. */
+  summary: string;
+  subcategories: { id: string; title: string }[];
+}
+
+/** What a catalog entry needs before it can start. */
+export type WorkflowCatalogNeed = 'repo' | 'project' | 'running_app' | 'requirements' | 'document' | 'runs' | 'nothing';
+
+/** One field the launch asks for, in order. */
+export interface WorkflowCatalogInput {
+  id: string;
+  label: string;
+  kind: 'text' | 'repo' | 'project' | 'url' | 'requirements' | 'seats';
+  required: boolean;
+}
+
+/**
+ * How a client starts an entry: `run` = `POST /runs {workflow}`; `demo` = `POST /projects/:id/demo`;
+ * `compose` = `POST /projects/:id/product/compose` (draft epics); `document` = a new interactive document
+ * of that style (its draft run); `chat` = a chat on its own page; `none` = nothing to launch (coming soon).
+ */
+export type WorkflowCatalogLaunch =
+  | { kind: 'run'; workflow: string }
+  | { kind: 'demo' }
+  | { kind: 'compose' }
+  | { kind: 'document'; style: 'web' | 'doc' | 'ppt' | 'brochure' }
+  | { kind: 'chat' }
+  | { kind: 'none' };
+
+/** The requesting operator's use of an entry (scope: {@link WorkflowCatalogResponse.usage}). */
+export interface WorkflowCatalogUsage {
+  /** Runs this operator launched under the entry's workflow (a retry is not a new launch). */
+  launches: number;
+  /** ISO 8601 launch time of the newest such run, or null. */
+  lastUsedAt: string | null;
+  /** Median wall time in minutes of those runs that COMPLETED, or null when none did. */
+  medianMinutes: number | null;
+}
+
+/** One card of the catalog. */
+export interface WorkflowCatalogEntry {
+  /**
+   * Unique, opaque card id. For `launch.kind === 'run'` it is `launch.workflow`, prefixed `run:` when a non-run
+   * card already holds that id (a saved preset called `presentation`). Launch by `launch.workflow`, never by `id`.
+   */
+  id: string;
+  category: WorkflowCatalogCategoryId;
+  /** A subcategory id of its category, or null. */
+  subcategory: string | null;
+  title: string;
+  /** What it does, one line. */
+  summary: string;
+  /** What you get, one line. */
+  outcome: string;
+  /** 0–4 short phrases saying when to pick it. */
+  useWhen: string[];
+  needs: WorkflowCatalogNeed[];
+  inputs: WorkflowCatalogInput[];
+  /** Static hint in minutes `[low, high]` from observed runs; null = not known. */
+  typicalMinutes: [number, number] | null;
+  /** Relative cost hint (agent phases and seats); null = not known. */
+  cost: 'low' | 'medium' | 'high' | null;
+  /** Shown as chips; searchable. */
+  tags: string[];
+  /** Searchable only. */
+  synonyms: string[];
+  status: 'available' | 'coming_soon' | 'unavailable';
+  /** Why coming soon or unavailable; null when available. */
+  statusNote: string | null;
+  launch: WorkflowCatalogLaunch;
+  /** The workflow requires QE acceptance before it delivers. */
+  requiresQe: boolean;
+  delivers: 'pr' | 'document' | 'video' | 'report' | 'answer' | 'none';
+  /** Where the definition lives: the engine's built-in preset, a crew workflow, the operator's saved preset, studio's own flow, or none yet. */
+  source: 'builtin' | 'crew' | 'saved' | 'studio' | 'none';
+  usage: WorkflowCatalogUsage;
+}
+
+/**
+ * `GET /workflows/catalog[?projectId=]` (api-types 0.168.0): the workflows as a categorised catalog with
+ * the requesting operator's usage, derived from the runs the daemon already records (the `run.launched`
+ * trail's principal, the run's resolved workflow). Additive: `GET /workflows` is unchanged.
+ */
+export interface WorkflowCatalogResponse {
+  categories: WorkflowCatalogCategory[];
+  /** By category order, then subcategory order, then catalog order. */
+  entries: WorkflowCatalogEntry[];
+  /** "Your top": up to 6 available entry ids with launches, by launches then most recent. */
+  top: string[];
+  usage: {
+    /** `operator`: every run this principal launched; `project`: only those filed in `projectId`. */
+    scope: 'operator' | 'project';
+    projectId: string | null;
+    /** The principal the usage is for (`Actor.id`; `local` on a loopback daemon). */
+    actorId: string;
+    /** Runs counted across every entry. */
+    launches: number;
+  };
+}
+
 // ── Projects (DES-PROJECT-001) — the experience-plane keystone ─────────────────
 
 /** Project lifecycle: `active ⇄ archived`, no hard delete (ADR §1.3). */
@@ -7303,6 +8051,18 @@ export interface ChatOpenBody {
    * engine without it is a 409. Send it only when `GET /health.capabilities.chatWorkflows` names it.
    */
   workflow?: string;
+  /**
+   * (api-types 0.169.0, DES-CHAT-ARTIFACTS-001 §6.3) "Ask about this" on a document no open chat holds: the
+   * artifact ref (`<mount>/<doc>`). Allowed for a chat with no `projectId`, or for a project chat whose project is the
+   * document's mount (checked before anything is read; else 400 `seed_out_of_scope`). Crew then checks the document
+   * exists (404 `seed_not_found`) and, for a project chat, that every repository it was made about belongs to the
+   * project (else 400 `seed_out_of_scope`). When the request names no `repoRefs` and its `scopeKind` is not
+   * `everything` or `project`, the chat reads the repositories the document was made about (its recorded binding);
+   * a `system` or `none` kind then becomes the repository scope. A document made about no repository seeds nothing.
+   * A non-person actor is refused (403 `seed_refused`). Send only when
+   * `GET /health.capabilities.chatArtifacts.context === true`.
+   */
+  seedFromArtifact?: string;
 }
 
 /** The scope a `POST /chats` caller may name (api-types 0.39.0, studio#323 R4). */
@@ -7355,7 +8115,8 @@ export interface ChatScope {
    *  0.35.0, F-2R2-008) names the UI action that would change a `bound: false` outcome, when one
    *  would: `projects.graph.refresh` = build the project graph from the project page. */
   graph: { bound: boolean; reason: string; repoLabel?: string; action?: ProjectGraphAction };
-  /** `crew.repo` members of the project whose registry record is gone — named, not readable. */
+  /** `crew.repo` members of the project whose registry record is gone — named, not readable. (0.155.0) Also
+   *  any repo in scope (project or `everything`) whose folder is missing (`repo_folder_missing`). */
   dangling: string[];
 }
 
@@ -7602,7 +8363,17 @@ export interface ChatUsage {
  */
 export type ChatTranscriptRecord =
   /** `attachments` (api-types 0.137.0): the files the message carried, ABSENT when none. */
-  | { at: number; turnId: string; kind: 'user'; text: string; seats: string[]; attachments?: ChatAttachment[] }
+  | {
+      at: number;
+      turnId: string;
+      kind: 'user';
+      text: string;
+      seats: string[];
+      attachments?: ChatAttachment[];
+      /** (api-types 0.170.0) Sent by the chat's owner, a person (the message route's own check). Only these words count
+       *  as the person's for a proposal (a demo address, a document they named). ABSENT for any other sender. */
+      owner?: true;
+    }
   | { at: number; turnId: string; kind: 'seat'; cliKey: string; text: string; ok: boolean; usage: ChatUsage | null }
   /**
    * The citation verdicts of the `seat` record with the same `turnId` + `cliKey` (api-types 0.68.0,
@@ -7635,7 +8406,218 @@ export type ChatTranscriptRecord =
    * 0.85.0, DC-S7): the rules remembered since they last heard from crew. Disclosed here so the
    * operator sees exactly what crew added; the `user` record keeps the operator's own words.
    */
-  | { at: number; turnId: string; kind: 'system'; text: string };
+  | { at: number; turnId: string; kind: 'system'; text: string }
+  /**
+   * What the seats of `turnId` were given beside the operator's words (api-types 0.169.0, DES-CHAT-ARTIFACTS-001
+   * §5.1): the open artifact's copies, the run briefs, and what was refused. Written with the turn's `user` record.
+   */
+  | ({ at: number; turnId: string; kind: 'context' } & ChatContextBinding)
+  /**
+   * (api-types 0.170.0, DES-CHAT-ARTIFACTS-001 §4.2) A proposal crew resolved from a seat's `wicked-make` block in the
+   * reply of `turnId`. A later `proposal` record with the same `proposal.pid` REPLACES it (a re-resolution after the
+   * document's head moved); a newer pid in the same chat supersedes an open one.
+   */
+  | { at: number; turnId: string; kind: 'proposal'; proposal: ArtifactProposal }
+  /** (api-types 0.170.0, §4.3 step 2) A person said go: what was accepted, written before anything starts. */
+  | ({ at: number; turnId: string; kind: 'proposal_accepting' } & ProposalAccepting)
+  /** (api-types 0.170.0) The proposal's answer: go (with what it started) or not now. */
+  | ({ at: number; turnId: string; kind: 'proposal_decided' } & ProposalDecided);
+
+// ── Chat proposals (api-types 0.170.0, DES-CHAT-ARTIFACTS-001 §4, slice A2) ─────────────────────────────────────────
+//
+// A seat proposes an artifact job in a fenced `wicked-make` block. Crew cuts it out of the reply (it never reaches a
+// reader), resolves it against its own records, and appends a `proposal` transcript record plus a `chatProposal`
+// frame. The card's facts are crew's, never the seat's. Only `POST /chats/:id/proposals/:pid` (a person, the chat's
+// owner) starts anything. Capabilities: `GET /health.capabilities.chatArtifacts.proposals` and one flag per operation.
+
+/** What a proposal makes. `create` and `demo` come from a catalog entry; `refine` changes a document; `theme` is a
+ *  studio appearance patch. */
+export type ArtifactProposalKind = 'create' | 'refine' | 'theme' | 'demo';
+
+/** One "From" chip: a source the block named, as crew resolved and authorized it. */
+export interface ProposalSource {
+  /** The token as crew reads it: `chat`, `page`, `message:<turnId>`, `run:<full id>`, `doc:<mount>/<doc>`,
+   *  `attachment:<id>` (a run prefix the seat wrote is resolved to the full id when it can be). */
+  token: string;
+  /** Plain words: "this conversation", "run 29bbbfb1 · stopped", "Release note v4". */
+  label: string;
+  /** `struck`: the draft never sees it; `reason` says why ("run 1a2b3c4d · not named in this chat"). */
+  status: 'ok' | 'struck';
+  reason?: string;
+  /** The project the source belongs to (`null`: Unfiled, or not a project's); absent for `chat` and `page`. A form that
+   *  changes the project strikes a chip whose project differs. */
+  projectId?: string | null;
+}
+
+/** "Codex and Claude Code: one writes, the other checks": two distinct eligible seats (never who writes). */
+export interface ProposalHelpers {
+  seats: string[];
+  label: string;
+}
+
+/** "About 10–20 min · 3 agent steps · median of 4 past documents here: 9 min, $0.62". Unknown parts are left out. */
+export interface ProposalTime {
+  /** The catalog entry's `typicalMinutes`. */
+  minutes: [number, number] | null;
+  /** The catalog entry's relative cost. */
+  cost: 'low' | 'medium' | 'high' | null;
+  /** Agent steps of the workflow. */
+  steps: number | null;
+  /** Over completed runs of the same workflow on this daemon. `costUsd` only from at least 3 runs whose every agent
+   *  step reported a cost (`costRuns` of them); else `null`. */
+  median: { runs: number; minutes: number; costUsd: number | null; costRuns: number } | null;
+  label: string;
+}
+
+/** A proposal as crew resolved it. Every line is crew's: the seat chose only the block's words. */
+export interface ArtifactProposal {
+  /** `<chatId>:<turnId>` for a turn's proposal (later slices add `<chatId>:redo:<runId>` / `:retry:`). */
+  pid: string;
+  chatId: string;
+  /** The turn whose reply carried the block; `null` for a crew-made proposal (`sourceRunId`). */
+  turnId: string | null;
+  sourceRunId?: string;
+  kind: ArtifactProposalKind;
+  /** The seat that wrote the block. */
+  seat: string;
+  /** The "What" line: `label` is "Slides · Domain coverage for new engineers"; `outcome` is the catalog entry's. */
+  what: { entry: string | null; title: string; label: string; outcome: string | null };
+  /** The brief (create), the ask (refine), or what to show (demo), as the seat wrote it. */
+  brief: string | null;
+  reason: string | null;
+  sources: ProposalSource[];
+  /** Repositories (names), each in the chat's scope. */
+  repos: string[];
+  /** `null` for a theme (no run). */
+  helpers: ProposalHelpers | null;
+  /** `null` for a theme. */
+  time: ProposalTime | null;
+  /** "Stops for you if the check fails. The plan or an escalation may also ask." `null` for a theme. */
+  stops: string | null;
+  /** The project the result is filed in; `label` is the project's name or "Not in a project · this chat". */
+  filedIn: { projectId: string | null; label: string };
+  /** refine: the document (`<mount>/<doc>`), its title, and the head it was proposed on. */
+  target?: { ref: string; title: string; base: number };
+  /** refine: the parts the seat pointed at (`data-wid`s); hand edits are kept unless the person says otherwise. */
+  touches?: string[];
+  /** theme: the partial appearance patch and the keys it changes. */
+  theme?: { name: string; patch: Record<string, string | number | boolean>; changes: string[] };
+  /** demo: the app address (from the person's words), the audience and what to show. */
+  demo?: { url: string; audience: string | null; show: string | null };
+  /** Go is refused with this reason ("Needs a second helper to check it"); the card shows it. `null` = Go is open. */
+  blocked: string | null;
+}
+
+/**
+ * What a person may change before Go (typed per kind; crew re-checks every edit with the rules of §4.2). In this
+ * release (slice A2) crew takes `title`, `brief`, `sources` and `helpers` on a create, `ask` and `helpers` on a refine,
+ * `name` and `patch` on a theme, and `audience`, `show` and `helpers` on a demo; `project`, `repos`, `url` and `allow`
+ * are refused (400 `edits_invalid`) until the slices whose forms edit them. A source the person adds that cannot be used
+ * is refused too, never dropped. An interrupted (accepting) proposal resumes with its accepted choices: only its
+ * `helpers` may change.
+ */
+export interface ProposalEdits {
+  /** create */
+  title?: string;
+  brief?: string;
+  sources?: string[];
+  repos?: string[];
+  project?: string | null;
+  /** refine */
+  ask?: string;
+  allow?: string[];
+  /** theme */
+  name?: string;
+  patch?: Record<string, string | number | boolean>;
+  /** demo */
+  url?: string;
+  audience?: string;
+  show?: string;
+  /** any kind with a run */
+  helpers?: string[];
+}
+
+/** What the accepted proposal is named by: the artifact, and the run derived from the pid. */
+export interface ProposalIdentity {
+  /** `<mount>/<doc>`: the document a create makes (its name derived from the pid) or a refine changes; `null` for a
+   *  theme or a demo. */
+  artifactRef: string | null;
+  /** A name-based UUID of the pid: the launch's `sessionId`, so a retry can only adopt it. */
+  runId: string;
+}
+
+/** What Go started. */
+export interface ProposalResult {
+  runId: string;
+  artifactRef: string | null;
+  /** Found already launched (a retry, a second tab) and adopted rather than started again. */
+  adopted: boolean;
+  /** The test configuration's recording stub took it: nothing was started. */
+  stub: boolean;
+}
+
+export interface ProposalAccepting {
+  pid: string;
+  /** The person's actor id. */
+  actor: string;
+  edits: ProposalEdits | null;
+  /** The effective proposal after the edits were applied and checked. */
+  resolution: ArtifactProposal;
+  identity: ProposalIdentity;
+}
+
+export interface ProposalDecided {
+  pid: string;
+  actor: string;
+  decision: 'go' | 'not_now';
+  /** `null` for not now. */
+  result: ProposalResult | null;
+}
+
+/** A proposal folded from its records. */
+export interface ChatProposalView {
+  proposal: ArtifactProposal;
+  /** `accepting`: Go was recorded and its result was not (an interrupted Go: "Go again" resumes the same identity). */
+  state: 'open' | 'accepting' | 'decided' | 'superseded';
+  decision?: 'go' | 'not_now';
+  result?: ProposalResult | null;
+  /** Unix millis of the decision. */
+  decidedAt?: number;
+}
+
+/** `POST /chats/:id/proposals/:pid` body. */
+export interface ChatProposalDecisionBody {
+  decision: 'go' | 'not_now';
+  edits?: ProposalEdits;
+}
+
+/**
+ * `POST /chats/:id/proposals/:pid` → 200: the proposal as decided (a repeat of the same decision answers the stored
+ * result again, so a lost response is safe to retry). Only a person answers: under `auth: required` a worker, agent or
+ * system token is refused; under `auth: off` every request is the local person (the daemon's documented local-mode
+ * posture, as for gates). Refusals carry `code`: 403 `proposal_refused` (not a person),
+ * 404 (no such chat or proposal, or a chat that is not the caller's under `auth: required`: its existence is not
+ * disclosed), 409 `proposal_superseded` | `proposal_decided` | `proposal_blocked` | `operation_unavailable` |
+ * `chat_busy` | `document_busy` | `source_gone` | `helper_unavailable` | `chat_gone` | `proposal_reresolved` (the
+ * document moved: `view.proposal` is the fresh one), 400 `edits_invalid`, 502 `launch_failed` (accepting stays
+ * recorded; Go again resumes the same identity). A 409 carries the current `view` when there is one.
+ */
+export interface ChatProposalDecisionResponse {
+  view: ChatProposalView;
+}
+
+/**
+ * `/ws` (api-types 0.170.0): a proposal record was appended to chat `chat` (the same record the transcript holds).
+ * `project_id`: the chat's project, when it has one. A `type` alias (like the daemon's other synthetic frames) so it
+ * satisfies {@link CoreEvent}'s index signature.
+ */
+export type ChatProposalFrame = {
+  type: 'chatProposal';
+  chat: string;
+  turn_id: string;
+  record: Extract<ChatTranscriptRecord, { kind: 'proposal' | 'proposal_accepting' | 'proposal_decided' }>;
+  project_id?: string;
+};
 
 // ── System chat: history, close, attachments (api-types 0.137.0, DES-SYSTEM-CHAT "Crew") ────────
 //
@@ -7762,6 +8744,84 @@ export interface ChatMessageBody {
    *  file: a path it can open (images as images where the CLI reads them) plus, for text and pdf,
    *  the extracted text. Send only when `GET /health.capabilities.chatAttachments === true`. */
   attachments?: string[];
+  /**
+   * (api-types 0.169.0, DES-CHAT-ARTIFACTS-001 §5.1) What studio shows beside the message: the artifact open on the
+   * surface it was sent from, the tab's appearance, and studio's page summary. Send only when
+   * `GET /health.capabilities.chatArtifacts.context === true`. Crew checks the chat's owner and scope before it
+   * reads anything; the seat gets labelled copies (data, never instructions), and the turn's `context` transcript
+   * record says what it was given.
+   */
+  context?: ChatMessageContext;
+}
+
+/** {@link ChatMessageBody.context} (api-types 0.169.0). */
+export interface ChatMessageContext {
+  /** The artifact on the surface the message was sent from (inline, pane, Made or full screen). */
+  artifact?: ChatArtifactContext;
+  /** The tab's effective appearance (DES §9), sent when `chatArtifacts.theme` is advertised. */
+  appearance?: ChatContextAppearance;
+  /**
+   * Studio's page summary (the context pack), kept apart from the person's typed words. Crew labels it as studio's
+   * and reads from it only the run of the page it describes and the runs added as chips. At most 32,768 characters.
+   */
+  page?: string;
+}
+
+/** {@link ChatMessageContext.artifact} (api-types 0.169.0). */
+export interface ChatArtifactContext {
+  /** `<mount>/<doc>`: the mount is a project id or `_unfiled`; the doc is the interactive document name. */
+  ref: string;
+  /** The version the person is looking at (≥ 0: a document's first version is 0), read after the editor's in-flight
+   *  writes finished. */
+  version: number;
+  /** The `data-wid` of each part the person selected (at most 16). */
+  anchors?: string[];
+}
+
+/** {@link ChatMessageContext.appearance} (api-types 0.169.0): studio's appearance scalars, plus an active preview. */
+export interface ChatContextAppearance {
+  theme?: string;
+  accent_h?: number;
+  accent_s?: number;
+  accent_l?: number;
+  ambient?: boolean;
+  ambient_still?: boolean;
+  /** The name of the theme proposal being previewed, when one is. */
+  previewOf?: string;
+}
+
+/**
+ * What one turn's seats were given (api-types 0.169.0, DES-CHAT-ARTIFACTS-001 §5.1 "Bindings kept"): the `context`
+ * transcript record. Paths are relative to the chat's scratch root. A reader folds it onto the turn's `user` record; a
+ * skin that does not know this kind ignores it.
+ */
+export interface ChatContextBinding {
+  /** The open artifact, when the message carried one in scope. */
+  artifact?: {
+    ref: string;
+    title: string;
+    kind: string;
+    /** The version the person was looking at, and the latest when the turn was sent. */
+    viewed: number;
+    head: number;
+    /** `null` for an Unfiled document. */
+    projectId: string | null;
+    /** The copies the seat read: `open/<mount>__<doc>-v<n>.html`. When the version they look at is missing or could
+     *  not be copied, only the latest's copy is here, and `viewed` still says what they asked about. */
+    copies: string[];
+    anchors: string[];
+  };
+  /** The run briefs the seat was given: `context/run-<id>-<sha8>.md` (named by content, so a later brief of the same
+   *  run never replaces these bytes), with the sha256 of the brief as written. */
+  runs: Array<{ id: string; status: string; brief: string; sha256: string }>;
+  /** What was named but not read, and why ("not in this chat's project", "no such run on this daemon"). */
+  refused: Array<{ token: string; reason: string }>;
+  /** Every run and document the person has named in this chat up to this turn. On later turns a run is kept while it
+   *  is still on this daemon and in the chat's scope, a document while it is in the chat's scope; an earlier brief is
+   *  offered again only while its file still holds the bytes its sha256 records. */
+  named: { runs: string[]; docs: string[] };
+  /** Studio's page summary rode as `context.page` (true), never mixed into the person's words. */
+  page: boolean;
 }
 
 /** `GET /chats/:id` → 200. */
@@ -8436,8 +9496,26 @@ export interface DiagnosticsResponse {
    *  — see `DiagnosticsVault`. `null` on a route set booted without an engine adapter; ABSENT on an
    *  older daemon. */
   vault?: DiagnosticsVault | null;
+  /** (crew#1147) The engine's repo-checks floor cache usage (`Core.floorCacheUsage`): `path` is shown as
+   *  `~/...`, never a home path; `repos` is largest first. The engine walks the cache, so the daemon
+   *  caches this answer for 60 s. `{ error }` when the engine has no worker home; `null` on an addon
+   *  without the static; ABSENT on an older daemon. */
+  floorCache?: DiagnosticsFloorCache | null;
 }
 
+/** `DiagnosticsResponse.floorCache` (crew#1147). Every `path` is `~/...`. */
+export type DiagnosticsFloorCache =
+  | {
+      path: string;
+      bytes: number;
+      totalCapBytes: number;
+      repoCapBytes: number;
+      idleTtlSecs: number;
+      repos: Array<{ name: string; bytes: number; leaves: number }>;
+      logs: { path: string; bytes: number; capBytes: number };
+    }
+  | { error: string };
+
 /**
  * (api-types 0.130.0, crew#1068) `DiagnosticsResponse.vault`: what the daemon exported to the engine
  * as `WICKED_VAULT_BIN` at boot. `shipped` = crew's own `wicked-vault` dependency's bin (an absolute
@@ -8909,8 +9987,33 @@ export type SystemLevel = 'green' | 'yellow' | 'red';
 /** The existing action an attention item or row offers (the snapshot itself is read-only):
  *  `sign_in` — the CLI's sign-in (`POST /seats/:cli/login…` / the Agents page); `recheck` — read
  *  the snapshot again (every probe runs fresh per read); `open_gate` — the run's open gate;
- *  `open_run` — the run. */
-export type SystemActionKind = 'sign_in' | 'recheck' | 'open_gate' | 'open_run';
+ *  `open_run` — the run. (0.162.0) `rebuild_seat_images` — `POST /system/seat-images/rebuild`
+ *  (the `seat_images` row: missing or unheld seat images); a skin that does not know a kind shows
+ *  the item without its button. */
+export type SystemActionKind = 'sign_in' | 'recheck' | 'open_gate' | 'open_run' | 'rebuild_seat_images';
+
+/** (0.162.0) `POST /api/v1/system/seat-images/rebuild` (a person only: 403 `{ error }` for an agent
+ *  or plugin bearer) → 202 once the engine process started; 409 while a rebuild runs; 503 on the
+ *  host floor, when crew cannot reach or start the engine binary, when the engine's seat image
+ *  status does not answer, when the roster cannot be read, or when no roster seat has an engine seat
+ *  image (`started: false` with why). A running rebuild is 409 before anything else is asked. The rebuild runs `wicked-core seat-image build <roster seats>` in the background (minutes;
+ *  it also holds an operator's own image); its progress reads on the `seat_images` row
+ *  (`details.rebuild`). */
+export interface RebuildSeatImagesResponse {
+  started: boolean;
+  /** Why it did not start; absent when it did. */
+  reason?: string;
+  rebuild: {
+    running: boolean;
+    startedAt: string;
+    finishedAt: string | null;
+    rc: number | null;
+    tail: string[];
+    /** The last output line that reads as a failure; `null` when none. */
+    error: string | null;
+    clis: string[];
+  } | null;
+}
 
 /** Where an item points. A skin maps it to its own route; crew never spells a studio URL. */
 export type SystemTarget =
@@ -9165,7 +10268,9 @@ export interface SystemRun {
   liveness: SystemRunLiveness;
   /** Plain-words why ("waiting on you: plan approval", "no event for 42 min"). */
   reason: string;
-  /** The cursor unit's phase (`phase_ref`, else `stage`); `null` before planning. */
+  /** The step the cursor unit is on, as display words: the step id its unit id names (`answer-1` → `answer 1`),
+   *  else a named `phase_ref`, else its catalog entry, else its `stage`; an engine-numbered step (`unit-N`, `uN`)
+   *  never shows. `null` before planning. */
   phase: string | null;
   /** The cursor unit's ord; `null` when none is in flight. */
   unitOrd: number | null;
@@ -9203,7 +10308,21 @@ export type SystemInfraKey =
   | 'stores'
   | 'seat_floor'
   | 'disk'
-  | 'load';
+  | 'load'
+  /** (0.155.0) The registered repositories' folders: `down` while any is missing (moved or deleted),
+   *  naming each with its path; `details.missing` lists `{ id, name, path }`. ABSENT before. */
+  | 'repos'
+  /** (0.162.0) The container seats' images (wicked-core `seat-image status`): `down` when a missing
+   *  seat image cannot be built (the operator's base is gone with no recipe, or an operator image is
+   *  missing) or the runtime VM disk is at 92 % or more; `degraded` when roster images are missing
+   *  (the next unit builds each first), not yet held against a runtime's image cleanup, the base is
+   *  missing, or the VM disk is at 75 % or more (a kubelet deletes unheld images from 85 %);
+   *  `unknown` when the engine, the roster or the disk could not be read. `details`: `images`
+   *  (`base`, `baseRecipe`, `holdSupported`, `floor`, `seats[]` with `present`/`held`/
+   *  `operatorImage`), `disk` (`totalBytes`, `availBytes`, `usedPct`), `missing`, `unheld`,
+   *  `imageGcHighPct`, `rebuild` (a running or the last rebuild, its output's last lines live).
+   *  `off` on the host floor. ABSENT before. */
+  | 'seat_images';
 
 export interface SystemInfraRow {
   key: SystemInfraKey;
@@ -11095,6 +12214,8 @@ export interface DecidedGate {
   creator: { seat: string; phase: string | null; ord: number } | null;
   /** A standing order could have approved this gate (a phase-review gate of a run that lands no doctrine). */
   orderApprovable: boolean;
+  /** (api-types 0.156.0) Answered by voice and confirmed on screen ({@link GateDecision.input}); absent otherwise. */
+  input?: 'voice';
 }
 
 /** `GET /gates/decided`'s 200. A malformed `since` answers 400. */
@@ -12100,6 +13221,23 @@ export interface EditorControl {
   maxChars?: number;
 }
 
+/**
+ * How an editor looks on studio's Plugins page (program DES-LEARN §2; api-types 0.157.0). Every image is a `data:` URL
+ * (`image/svg+xml`, `image/png` or `image/webp`, base64) the registry read from the editor's own files, bounded (icon
+ * 16 KB, preview 200 KB) and never through a link: no path and no remote URL is on the wire. Each field is optional;
+ * a file that is missing, too big or not the image its name says is left out (the editor is still served).
+ */
+export interface EditorVisuals {
+  /** Drawn on `color`, at about 18 px. */
+  icon?: string;
+  /** `#rrggbb`. */
+  color?: string;
+  /** A 16:9 picture of the editor at work; a `dark` one is used on a dark theme (else `light`). */
+  preview?: { light?: string; dark?: string };
+  /** The editor offers a live preview on its own sample (reserved: studio draws one for run plugins today). */
+  live?: boolean;
+}
+
 /**
  * One registered editor, as Settings → Editors renders it. No path is on the wire: the bundle is
  * fetched at `entry_url` (`GET /editors/:id/:version/entry`, the §8.2 headers, re-hashed per serve).
@@ -12132,6 +13270,11 @@ export interface EditorView {
   /** `studio-bundle`: first-party, shipped with studio. `pack`: a third-party pack the operator installed. */
   source: 'studio-bundle' | 'pack';
   entry_url: string;
+  /** Its one line for the Plugins page (at most 160 characters). Absent when the manifest has none, and from a daemon
+   *  that predates the field (api-types 0.157.0). */
+  description?: string;
+  /** Its icon, colour and preview (api-types 0.157.0). Absent when it declares none that read. */
+  visuals?: EditorVisuals;
 }
 
 /** `GET /editors` (operator+). */
@@ -13013,3 +14156,112 @@ export interface DefaultEvalDetail {
   report: DefaultEvalReport;
   cases: DefaultEvalCase[];
 }
+
+// ── Voice mode, phase 1 (program DES-VOICE; api-types 0.156.0) ─────────────────────────────────────────
+
+/**
+ * `GET /voice/status` (and the answer of `POST|DELETE /voice/model`). Speech to text runs on THIS machine:
+ * whisper.cpp's CLI plus one model file. Every voice route is the human operator's alone, on loopback
+ * (403 `human_operator_only` / `voice_loopback_only`).
+ */
+export interface VoiceStatus {
+  /** Audio is transcribed on this machine and never sent anywhere. Always `true` in phase 1. */
+  local: true;
+  /** The engine and the model are both here: `POST /voice/transcribe` can run. */
+  ready: boolean;
+  engine: {
+    name: 'whisper.cpp';
+    found: boolean;
+    /** Where the CLI was found; `null` when it was not. */
+    path: string | null;
+    /** How to install (or upgrade) it on this platform, when it is missing or too old; else `null`. */
+    install: string | null;
+    /** (api-types 0.158.0) The version it reports (`--version`); `null` when not found, or too old to report one. */
+    version: string | null;
+    /** (api-types 0.158.0) New enough for voice (1.8.0 or later, reporting `--version`): a stdin transcription prints
+     *  its text and writes no file. An older engine is refused with 409 `voice_engine_outdated`, before any audio. */
+    supported: boolean;
+  };
+  model: {
+    /** `base.en`. */
+    name: string;
+    present: boolean;
+    /** The model file's size; `null` when absent. */
+    bytes: number | null;
+    /** What the consent says before anything is fetched. */
+    approxBytes: number;
+    /** Where it is fetched from (`huggingface.co/ggerganov/whisper.cpp`). */
+    source: string;
+    /** A download in progress, or the last one's failure; `null` when none. */
+    download: {
+      state: 'running' | 'failed';
+      receivedBytes: number;
+      totalBytes: number | null;
+      startedAt: string;
+      error: string | null;
+    } | null;
+  };
+}
+
+/** `POST /voice/model`: the person's consent to fetch the model (202 = started; 200 = already here; 409
+ *  `voice_download_running`). Audited `voice.model.download_started`. `DELETE /voice/model` removes it. */
+export interface PostVoiceModelBody {
+  consent: true;
+}
+
+/**
+ * `POST /voice/transcribe` with an `audio/wav` body (16 kHz mono 16-bit, at most 8 MiB). The audio is held in
+ * memory for the call and dropped: never stored, logged or audited. Errors carry `code`:
+ * `voice_engine_missing` / `voice_engine_outdated` / `voice_model_missing` (409), `voice_audio_invalid` (400/415),
+ * `voice_audio_too_large` (413), `voice_busy` (429: one runs and one waits), `voice_timeout` (504), `voice_failed` (500).
+ */
+export interface VoiceTranscribeResponse {
+  /** The words, one line; empty when nothing was said. */
+  text: string;
+  ms: number;
+  model: string;
+}
+
+/** A section a widget registers in the `voice-dashboard` panel slot (the `panels[]` shape of a run plugin). */
+export interface VoicePanelDecl {
+  slot: 'voice-dashboard';
+  id: string;
+  title: string;
+  /** 1-99, lower first. */
+  order: number;
+}
+
+/**
+ * A USER-MADE dashboard widget: a declarative plugin (no code, nothing framed) that shows one field of
+ * `GET /system` or `GET /diagnostics` as a number or a chart. `metric.path` is a field path:
+ * `infra[key=load].details.load1`, `runs.length`, `toReview`.
+ */
+export interface VoiceWidgetManifest {
+  /** `user.<slug>`. */
+  id: string;
+  title: string;
+  version: 1;
+  kind: 'metric';
+  panels: [VoicePanelDecl];
+  metric: {
+    source: 'system' | 'diagnostics';
+    path: string;
+    display: 'number' | 'chart';
+    unit?: string;
+  };
+  createdAt?: string;
+}
+
+/** `GET /voice/dashboard`: this person's dashboard (keyed by actor id). `layout: null` = never saved. */
+export interface VoiceDashboard {
+  /** Widget ids in order: `builtin.<id>` or a user widget's `user.<slug>`. */
+  layout: string[] | null;
+  widgets: VoiceWidgetManifest[];
+  updatedAt: string | null;
+}
+
+/** `PUT /voice/dashboard` (at most 24 on the layout, 16 user widgets; every `user.*` on the layout is in `widgets`). */
+export interface PutVoiceDashboardBody {
+  layout: string[];
+  widgets: VoiceWidgetManifest[];
+}