wicked-crew-api-types 0.69.0 → 0.77.0

package/index.d.ts

@@ -231,6 +231,19 @@ export interface HealthCapabilities {
    * on such a daemon.
    */
   seatChipOnCreate?: boolean;
+  /**
+   * `AgentSession.chat_id` is served on every run launched from a chat, terminal ones included
+   * (C1; crew ≥ the release carrying api-types 0.71.0). ABSENT on a daemon before the field — read
+   * as `false`: group such a daemon's runs one session per run.
+   */
+  runChatId?: boolean;
+  /**
+   * Repo-bound runs get an EVIDENCE ROOT for walkthroughs (WT-W1, api-types 0.74.0): the engine
+   * addon takes `LaunchOptions.evidenceRoot` (wicked-core-ts ≥ 0.7.35), so a walkthrough step on a
+   * run launched now can record and pass. `GET /runs/:id/walkthrough` answers on every daemon that
+   * has the field. ABSENT or `false` — a walkthrough step on this daemon's runs fails closed.
+   */
+  walkthroughRoots?: boolean;
 }
 
 /** One `GET /health.warnings[]` entry (additive; wicked-core#411 / wicked-crew#497). */
@@ -344,6 +357,13 @@ export interface AgentSession {
    * plus `denial_reason` (crew#318's message), both already on the list wire.
    */
   delivery?: 'delivered' | 'pushed' | 'stranded' | 'vacuous' | 'none';
+  /**
+   * (crew#755; api-types 0.76.0) `'text_only'` on a COMPLETED free-text run (launched with neither a
+   * workflow nor a plan) that had no repo and no write root of its own: whatever it did, it did in
+   * text — nothing was changed, checked or delivered. Show it as such, never as plain completed
+   * work. ABSENT on every other run (and on a daemon before the field).
+   */
+  outcome?: 'text_only';
   /**
    * The delivered PR's URL (crew#393; api-types 0.18.0) — present exactly when
    * `delivery === 'delivered'`; absent otherwise (absence is the one spelling, never `null`).
@@ -492,6 +512,13 @@ export interface AgentSession {
    * this field.
    */
   chat_grounded?: boolean;
+  /**
+   * The chat this run was launched from (`LaunchRunBody.chatId`; C1, api-types 0.71.0) — on EVERY
+   * run, terminal ones included, and after a daemon restart (read back from the `run.launched`
+   * trail entry). ABSENT — never `null` — when the run was not launched from a chat, or on a daemon
+   * before the field: check `GET /health.capabilities.runChatId` before grouping runs by chat.
+   */
+  chat_id?: string;
   /**
    * The engine's plan state (wicked-core `TeamPlanState`, DES-TEAMING-002 §8.4-§8.6; api-types
    * 0.46.0 types the engine field) — present on a run launched from a PLAN or a PRESET, ABSENT on
@@ -508,6 +535,14 @@ export interface AgentSession {
    * workflow ids.
    */
   run_identity?: RunIdentity;
+  /**
+   * The run's EVIDENCE ROOT (WT-W1, DES-walkthrough-proof §4.2; api-types 0.74.0), minted by the
+   * daemon for every repo-bound run on an engine that takes it: `<root>/author/<plan step>/` is
+   * the walkthrough author's write dir, `<root>/<review step>/` the proof root only the jailed
+   * `walkthrough_review` Tool writes. Read the walkthrough through `GET /runs/:id/walkthrough`, not
+   * from this path. ABSENT on a repo-less run, on an engine before the field, and on older runs.
+   */
+  evidence_root?: string;
 }
 
 /**
@@ -2544,7 +2579,13 @@ export interface ConformanceRule {
   statement: string;
   severity: 'info' | 'warn' | 'error' | 'critical';
   confidence: number;
-  targets: { language?: string; layer?: string; framework?: string };
+  /**
+   * Facets. `language` / `layer` / `framework` are wildcards (absent = every value). `project`
+   * (api-types 0.77.0, DC-S3; engine >= wicked-core-ts 0.7.35) is ASYMMETRIC: a rule with no project
+   * applies everywhere; a rule with one is recalled only for that project. A landed policy proposal
+   * keeps its `project` facet here.
+   */
+  targets: { language?: string; layer?: string; framework?: string; project?: string };
   symbol_ref?: string;
   compliance?: { framework: string; control_id: string };
   /** Where the rule came from. Doc-ingested rules keep `path@sha#id` in `ref`; UI/chat-authored
@@ -2588,6 +2629,8 @@ export interface ConformanceRule {
    * pre-bump binding), so a `since`/`until` filter cannot assert an undated rule in range.
    */
   created_at?: number;
+  /** (api-types 0.77.0, DC-S1/DC-S3) The rule ids this rule replaces. Absent when it replaces none. */
+  supersedes?: string[];
 }
 
 /** Facet query for `GET /governance/rules/preview`. All fields are optional. */
@@ -3933,6 +3976,12 @@ export interface LinkedIssue {
 export interface LaunchRunResponse {
   runId: string;
   linkedIssues?: LinkedIssue[];
+  /**
+   * (crew#755; api-types 0.76.0) PRESENT when the launch named neither a `workflow` nor a `plan`:
+   * the run uses the engine's free-text planner (one step, the brief verbatim; no phases, checks or
+   * delivery), and `notice` says so in words a composer can show. ABSENT on every other launch.
+   */
+  freeText?: { notice: string };
 }
 
 /**
@@ -4252,6 +4301,12 @@ export interface GitContributor {
 export interface SystemSettings {
   /** Max nodes returned by wicked-estate graph-view (default 150). */
   graphNodeLimit: number;
+  /**
+   * The watch registry's operator settings (TR-W5a, api-types 0.73.0): only `enabled` and
+   * `threshold` of a shipped entry, and the LLM lane switch. A `watch` patch needs a human actor
+   * (a worker's bearer is refused 403); the daemon stamps who changed what and when.
+   */
+  watch?: WatchSettings;
   /**
    * Base directory for the ENGINE-OWNED worker CLI config homes (the claude worker home is
    * `<root>/claude`). The daemon applies it as env `WICKED_WORKER_HOME` at boot and on every
@@ -6288,6 +6343,12 @@ export interface PolicyLandingResult {
   ruleId?: string;
   /** The steering type derived from the proposal's `kind_type` (`policy:<type>`). Present on `landed`. */
   steering_type?: SteeringType;
+  /**
+   * (api-types 0.77.0, DC-S3) The project the landed rule is scoped to — the proposal's `project`
+   * facet, kept as `targets.project` and confirmed by reading the rule back. Absent on a landing
+   * with no project (the rule applies everywhere).
+   */
+  project?: string;
   /** Present iff `outcome:"failed"` — the loud reason the rule did not land. */
   error?: string;
 }
@@ -6489,6 +6550,166 @@ export interface DemoView {
   syntheticLabelled: boolean;
 }
 
+/** What `POST /runs/:id/demo/export` makes (EP-C3; api-types 0.72.0). The MP4 itself needs no export: download `video.path`. */
+export type DemoExportFormat = 'gif' | 'poster';
+
+/**
+ * `POST /runs/:id/demo/export` body (EP-C3; api-types 0.72.0). `gif` encodes the stitched MP4 into
+ * `demo-video/demo.gif` (two-pass palette, 10 fps, 720 px wide); `poster` writes one frame to
+ * `demo-video/poster.jpg`. The daemon encodes with ffmpeg off its event loop and a timeout (GIF 180 s,
+ * poster 30 s), only at the review gate or once the run has ended. Refusals: 400 a bad body, 404 not a demo run, 409 no stitched MP4 yet / the run is still recording / `demo-video/` changed mid-encode, 422 no frame
+ * at `atSec`, 502 ffmpeg failed, 503 no ffmpeg on the daemon host (`hint` says how to install it),
+ * 504 the encode ran past its timeout. A second identical request while one encodes joins it.
+ */
+export interface DemoExportBody {
+  format: DemoExportFormat;
+  /** Poster only: the frame, in seconds from the start (0 … 86400). Default: the first chapter marker + 1 s, or 1 s with no markers. */
+  atSec?: number;
+}
+
+/** `POST /runs/:id/demo/export` → 200: the file, ready for `GET /runs/:id/demo/file?path=`. */
+export interface DemoExportResponse {
+  format: DemoExportFormat;
+  /** `demo-video/demo.gif` or `demo-video/poster.jpg` (root-relative). */
+  path: string;
+  bytes: number;
+}
+
+// ── Walkthroughs: the recording view (WT-W1, DES-walkthrough-proof §4.10; api-types 0.74.0) ──────
+
+/**
+ * Where a walkthrough stands (`WalkthroughView.state`), read from the run's walkthrough pair — the
+ * `walkthrough_plan` unit (the author, an evaluator) and the `walkthrough_review` unit (the jailed
+ * engine-run recorder) — and the recorder's files in the proof root.
+ *
+ *   - `authoring`     the author has not finished the storyline (also: the run has no walkthrough
+ *                     step yet — `stepId` is then `null` and `cause` says so);
+ *   - `linting`       the author's storyline was refused by its pinned lint (the unit was denied;
+ *                     its escalation gate is open, `cause` is the lint's reason);
+ *   - `starting_app`, `recording`, `judging`
+ *                     the recorder is queued or running: its `progress.json` names the phase;
+ *   - `passed`, `failed`, `inconclusive`
+ *                     the recorder finished: `result.json`'s `overall` (PASS / FAIL / INCONCLUSIVE).
+ *                     A finished recorder with no readable `result.json` reads `inconclusive` with
+ *                     `cause: 'no_result'`.
+ */
+export type WalkthroughState =
+  | 'authoring'
+  | 'linting'
+  | 'starting_app'
+  | 'recording'
+  | 'judging'
+  | 'passed'
+  | 'failed'
+  | 'inconclusive';
+
+/** One chapter's verdict, as the recorder's judge wrote it (§4.5). */
+export type WalkthroughVerdict = 'PASS' | 'FAIL' | 'INCONCLUSIVE';
+
+/** One check of a chapter: what was captured on screen or underneath, and whether its verifier passed. */
+export interface WalkthroughCheck {
+  id: string;
+  /** `on_screen`, `saved_state`, `events`, `side_effects`, `output`, `must_not_happen`, `cross_check`. */
+  kind: string;
+  /** The plain sentence the check proves. */
+  sentence: string;
+  /** `null` when the check never ran (its `ctx.check` was not reached, or the take was refused). */
+  passed: boolean | null;
+  /** Seconds into the chapter when the check was captured; `null` when it never ran. */
+  atSec: number | null;
+  /** Proof-root-relative paths (for `GET /runs/:id/walkthrough/file`). */
+  evidence: string[];
+  vaultEntry: string | null;
+  detail: string | null;
+}
+
+/** A capped leg of a chapter (§4.5 "the honest cap"): e.g. the provider leg ran against a sink. */
+export interface WalkthroughLeg {
+  leg: string;
+  claim_level: string;
+  reason: string;
+}
+
+/** One chapter of a walkthrough: the demo chapter plus its verdict and checks. */
+export interface WalkthroughChapter extends DemoChapter {
+  /** 1-based position and the chapter count, for "chapter 2 of 5". */
+  index: number;
+  total: number;
+  /** `null` until the judge has written it. */
+  verdict: WalkthroughVerdict | null;
+  /** How many takes the recorder made of this chapter (failed takes are kept, never stitched). */
+  takes: number;
+  /** Seconds into the chapter of the first failing check; `null` unless it failed. */
+  failedAtSec: number | null;
+  /** The failing frame (proof-root-relative), when the recorder kept one. */
+  failedFrame: string | null;
+  /** The plan step ids this chapter proves. */
+  proves: string[];
+  legs: WalkthroughLeg[];
+  checks: WalkthroughCheck[];
+}
+
+/**
+ * Per plan step, whether a sealed walkthrough proves it (§4.9). Computed at every read, never stored.
+ * `checked`: every proving chapter of the newest sealed walkthrough passed; `failed`: one failed;
+ * `claimed`: the step passed its own gate and no sealed chapter proves it; `owned_by_you`: the
+ * accepted plan's override removed the walkthrough pair.
+ */
+export type WalkthroughCheckState = 'checked' | 'failed' | 'claimed' | 'owned_by_you';
+
+export interface WalkthroughStepState {
+  stepId: string;
+  checkState: WalkthroughCheckState;
+  provedBy: Array<{ chapter: string; atSec: number | null }>;
+}
+
+/**
+ * `GET /runs/:id/walkthrough?step=` → 200 for every known run (404 for an unknown run, or a `step`
+ * that names no walkthrough step of it). `step` is the `walkthrough_review` step id (or its author's
+ * `walkthrough_plan` step id); omitted, the NEWEST pair. Studio polls it, as Demo mode polls `DemoView`.
+ */
+export interface WalkthroughView {
+  runId: string;
+  /** The `walkthrough_review` step id; `null` when the run has no walkthrough step. */
+  stepId: string | null;
+  /** The `walkthrough_plan` step that authored it; `null` when there is none. */
+  planStepId: string | null;
+  state: WalkthroughState;
+  /** Why the state is what it is, when there is something to say (`no_walkthrough`, `no_evidence_root`,
+   *  the recorder's own causes such as `unjailed_host`, `fixture_unavailable`, `storyline_refused`). */
+  cause: string | null;
+  /** Evaluator ≠ creator: the seat that wrote the checks, and the seats that built what they check. */
+  seat: { evaluator: string | null; builders: string[] };
+  /** The tree id the recorder recorded (`git archive` of it is what ran). */
+  tree: string | null;
+  /** Always `false`: a later creator step re-inserts the pair after it (§4.8). Kept so an old plan shape reads honestly. */
+  stale: false;
+  /** The take's seal was found in the engine store and every re-check against the files on disk held (WT-W2). */
+  sealed: boolean;
+  /** Proof-root-relative paths of the stitched take; `null` until there is one. */
+  video: { mp4: string | null; poster: string | null; markers: DemoMarker[] };
+  chapters: WalkthroughChapter[];
+  /** Per creator step, the check state from THIS pair's take — computed at every read from its re-verified seal (WT-W2). */
+  steps: WalkthroughStepState[];
+}
+
+/**
+ * `GET /runs/:id/acceptance` → `walkthrough` (WT-W2, DES-walkthrough-proof §4.9; api-types 0.75.0):
+ * the walkthrough half of the gate. One row per `walkthrough_review` step the run's requirement names,
+ * each re-verified at this read — the seal (the last `WALKTHROUGH-SEAL` line of the recorder's
+ * engine-captured output), `bundle_sha` recomputed from the proof root, and the proof root's stamped
+ * ledger verdicts against the sealed chapter verdicts. The gate is deny-dominates across the repo
+ * ledger and every row: a missing, mismatched ("changed after it was sealed") or non-PASS seal
+ * denies. ABSENT when the requirement names no walkthrough step.
+ */
+export interface RunAcceptanceWalkthrough {
+  roots: Array<{ stepId: string; sealed: boolean; satisfied: boolean; reason: string }>;
+  /** Every row's seal held. */
+  sealed: boolean;
+  /** Per creator step, from the NEWEST walkthrough of the run. */
+  steps: WalkthroughStepState[];
+}
+
 /** `POST /proposals/:id/reject` → 200. */
 export interface RejectProposalResponse {
   ok: true;
@@ -7075,6 +7296,248 @@ export interface TeamEventFrame {
   project_id?: string;
 }
 
+// ── The watch registry wire contract (DES-TRIGGER-REGISTRY-001 §4.5; TR-W4; api-types 0.70.0) ──
+//
+// The registry is advisory by construction: a watch row can never allow, approve or block. Its
+// facts are two bus types owned by crew (`wicked.crew.watch_finding.{raised,cleared}`), relayed
+// onto `/ws` as {@link WatchEventFrame} by a bus tap (never broadcast directly, so the socket and
+// the record cannot disagree). Types only: the runtime lands in TR-W5a, and a daemon without it
+// simply never sends these frames or serves these routes.
+
+/** The two bus types the watch registry publishes. */
+export type WatchEventType = 'wicked.crew.watch_finding.raised' | 'wicked.crew.watch_finding.cleared';
+
+/** How a watch row is meant: a contradiction in the work's own evidence, a look-worthy flag, or a candidate rule for the review queue. */
+export type WatchEmitAs = 'finding' | 'flag' | 'proposal';
+export type WatchSeverity = 'high' | 'medium' | 'info';
+/** The Watchtower's kind column. There is no `needs` kind: needs-you stays studio's own fold. */
+export type WatchKind = 'problem' | 'decision' | 'done' | 'quiet' | 'delivery';
+/** `p0` is never shed; `p1` is shed after `p2` when the push ring overflows. */
+export type WatchPriority = 'p0' | 'p1' | 'p2';
+
+/** Where in the run a watch row points: "Jump in" scrolls to the nearest event at or after `at`. */
+export interface WatchAnchor {
+  run_id: string;
+  ord: number | null;
+  attempt: number | null;
+  /** Unix millis of the source event. */
+  at: number;
+}
+
+/** One piece of evidence a watch row cites. `run_event` names a persisted CoreEvent; `bus_row` a bus row. */
+export interface WatchEvidenceRef {
+  kind: 'run_event' | 'bus_row' | (string & {});
+  type: string;
+  ord?: number | null;
+  attempt?: number | null;
+  /** For `bus_row`: the cited row's `event_id`. */
+  event_id?: number;
+}
+
+/**
+ * The payload of `wicked.crew.watch_finding.raised`. Its first six fields are the team
+ * envelope's (`DES-TEAMING-002` §4.4). `watch_id` is `"w-"` + the deterministic key over
+ * (`run_id | "-"`, `entry_id`, `entry_version`, `subject`), so a replay or a redelivery resolves to
+ * the same row.
+ */
+export interface WatchFinding {
+  /** `null` for a row no run owns (a registry-internal flag such as `registry-lagging`). */
+  run_id: string | null;
+  ord: number | null;
+  attempt: number | null;
+  /** `"watch:<entry_id>@<entry_version>"`. */
+  by: string;
+  /** Unix millis the row was produced. */
+  at: number;
+  /** What it answers: `"<CoreEvent type>#<ord>:<attempt>"`, or a bus source row's idempotency key. */
+  re: string;
+  watch_id: string;
+  entry_id: string;
+  entry_version: number;
+  /** `"deterministic:<name>"` or `"llm:<prompt-ref>@<n>"`. */
+  check: string;
+  kind: WatchEmitAs;
+  severity: WatchSeverity;
+  watch_kind: WatchKind;
+  /** `"gate"`: render as one line on the open gate's existing row, never a new row. */
+  attach: 'gate' | null;
+  /** The run's project membership, as the relay tags frames; absent when the run is unfiled. */
+  project_id?: string;
+  /** The one plain sentence the Watchtower shows. */
+  sentence: string;
+  /** Entry-specific facts, at most 4 KB, redacted. */
+  facts: Record<string, unknown>;
+  anchor: WatchAnchor | null;
+  evidence: WatchEvidenceRef[];
+  /** Set for an `llm:*` check only. */
+  model: { seat: string; model: string; latency_ms: number } | null;
+  /** How many later rows this roll-up stands for (`0` on an ordinary row). */
+  rolled_up: number;
+}
+
+/** The fields every `wicked.crew.watch_finding.cleared` payload carries. */
+export interface WatchFindingClearedBase {
+  run_id: string | null;
+  ord: number | null;
+  attempt: number | null;
+  by: string;
+  at: number;
+  re: string;
+  /** The raised row this clears. */
+  watch_id: string;
+  entry_id: string;
+  entry_version: number;
+  project_id?: string;
+}
+
+/**
+ * The payload of `wicked.crew.watch_finding.cleared`, discriminated on `reason`: the raised row
+ * `watch_id` names is resolved (a later attempt passed, the worker produced output), dismissed by
+ * the operator ("Seen, not a problem": `dismissed_by` says who), or replaced by a roll-up
+ * (`replaced_by` names it). The set is closed on purpose: no clearing reason is allow-like.
+ */
+export type WatchFindingCleared =
+  | (WatchFindingClearedBase & { reason: 'resolved' })
+  | (WatchFindingClearedBase & { reason: 'dismissed'; dismissed_by: string })
+  | (WatchFindingClearedBase & { reason: 'rolled_up'; replaced_by: string });
+
+export interface WatchEventPayloads {
+  'wicked.crew.watch_finding.raised': WatchFinding;
+  'wicked.crew.watch_finding.cleared': WatchFindingCleared;
+}
+
+/** One watch bus row, discriminated on `event_type`. */
+export type WatchBusEvent = {
+  [K in WatchEventType]: { event_type: K; payload: WatchEventPayloads[K] };
+}[WatchEventType];
+
+/**
+ * A `/ws` frame carrying one `wicked.crew.watch_finding.*` bus row, relayed verbatim (the
+ * {@link TeamEventFrame} pattern). `project_id` is set when the run's membership files it.
+ */
+export interface WatchEventFrame {
+  type: 'watchEvent';
+  /** The whole bus row as wicked-bus delivers it. */
+  event: WatchBusEvent & { event_id: number; [k: string]: unknown };
+  project_id?: string;
+}
+
+/**
+ * What one check can see on one run. Studio never renders an empty list as "all clear" when an entry
+ * was `not_checked`; a `not_checked` entry always says why, in plain words ("no declared scope", "the
+ * daemon was down").
+ */
+export type WatchCoverage =
+  | { entry_id: string; state: 'checked' }
+  | { entry_id: string; state: 'not_checked'; reason: string };
+
+/** `GET /watch?project=&kind=&run=&since=&limit=`: the feed fold, newest first. */
+export interface WatchFeedResponse {
+  findings: WatchFinding[];
+  /**
+   * The clearing rows of the findings on this page (a late join folds them as the live
+   * `watch_finding.cleared` frames would: Fixed, Dismissed, rolled up). api-types 0.73.0.
+   */
+  cleared?: WatchFindingCleared[];
+  /** Present with `run=` only. */
+  coverage?: WatchCoverage[];
+}
+
+/**
+ * Where an entry's key point comes from. `core`: a CoreEvent from the daemon fan-in. `bus`: a pulled
+ * 4-segment bus type. `watchdog`: a stall-watchdog frame (`workerStalled`, …). `internal`: the
+ * registry's own tick or check-failure report (`registry-lagging`, `registry-check-failed`).
+ * (api-types 0.73.0 adds `watchdog` and `internal`.)
+ */
+export type WatchEntrySource = 'core' | 'bus' | 'watchdog' | 'internal';
+
+/** Who changed one operator setting of an entry, and when (stamped by the daemon, never the caller). */
+export interface WatchSettingStamp {
+  by: string;
+  /** Unix millis. */
+  at: number;
+}
+
+/** One entry's operator override in `SystemSettings.watch.entries`. */
+export interface WatchEntryOverride {
+  enabled?: boolean;
+  /** Merged over the shipped threshold, validated by the entry's check. */
+  threshold?: Record<string, unknown>;
+  /** Daemon-stamped; a caller cannot set these. */
+  enabled_changed?: WatchSettingStamp;
+  threshold_changed?: WatchSettingStamp;
+}
+
+/** `SystemSettings.watch`. */
+export interface WatchSettings {
+  entries?: Record<string, WatchEntryOverride>;
+  /** The LLM lane (off by default; TR-W9). */
+  llm?: boolean;
+}
+
+/**
+ * One registry entry (`packages/crew/watch/entries/<id>.json`), as `GET /watch/entries` serves it:
+ * the effective entry (the operator's `enabled` / `threshold` override applied) plus its threshold
+ * in plain words. The schema has no allow-like `emit.as` value.
+ */
+export interface WatchEntry {
+  /** Stable, `[a-z0-9-]{3,48}`; equals the file name. */
+  id: string;
+  /** Bumped on any semantic change; part of every finding key. */
+  version: number;
+  /** See {@link WatchEntrySource}. A `bus` type is a 4-segment `wicked.<domain>.<noun>.<verb>` type. */
+  on: { source: WatchEntrySource; type: string };
+  /** JSON-path equality, AND of keys; an array means "any of". */
+  filter: Record<string, unknown>;
+  check: string;
+  params: Record<string, unknown>;
+  threshold: Record<string, unknown>;
+  emit: {
+    as: WatchEmitAs;
+    severity: WatchSeverity;
+    watch_kind: WatchKind;
+    attach: 'gate' | null;
+    /** Past `per_run`, one roll-up replaces the rest. */
+    rate: { per_run: number };
+  };
+  priority: WatchPriority;
+  enabled: boolean;
+  /** The threshold in plain words, for "When Studio speaks up". Always set on `GET /watch/entries`. */
+  threshold_text: string;
+}
+
+/** Who changed an operator-adjustable entry setting, and when (read from the `settings.updated` audit entry). */
+export interface WatchEntryChange {
+  id: string;
+  by: string;
+  /** Unix millis. */
+  at: number;
+}
+
+/** `GET /watch/health`. Every turned-off entry and every changed threshold is listed with who and when. */
+export interface WatchHealth {
+  /** The registry is running. `false` ⇒ `reason` says why. */
+  armed: boolean;
+  reason: string | null;
+  sources: {
+    bus: 'ok' | 'lagging' | 'down' | (string & {});
+    core: 'ok' | 'lagging' | 'down' | (string & {});
+    watchdog: 'ok' | 'lagging' | 'down' | (string & {});
+  };
+  queue: { depth: number; hwm: number; shed_by_priority: Record<WatchPriority, number> };
+  tail_lag_ms: number;
+  emit: { failed: number };
+  entries: {
+    loaded: number;
+    refused: Array<{ id: string; reason: string }>;
+    off: WatchEntryChange[];
+    thresholds_changed: WatchEntryChange[];
+  };
+  llm: { enabled: boolean; inflight: number; timeouts: number; skipped_no_seat: number };
+  /** `core_gap: true`: runs that started and ended while the daemon was down were not evaluated this boot. */
+  replay?: { core_gap: boolean };
+}
+
 /** One `wicked.team.*` bus row as `GET /runs/:id/team` returns it. */
 export type TeamRow = TeamBusEvent & {
   event_id: number;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wicked-crew-api-types",
-  "version": "0.69.0",
+  "version": "0.77.0",
   "description": "The wire contract of the wicked-crew daemon's /api/v1 REST surface and /ws CoreEvent frames \u2014 types only, zero runtime",
   "type": "module",
   "types": "./index.d.ts",