wicked-crew-api-types 0.92.0 → 0.95.0

package/index.d.ts

@@ -539,6 +539,25 @@ export interface AgentSession {
    * before the field: check `GET /health.capabilities.runChatId` before grouping runs by chat.
    */
   chat_id?: string;
+  /**
+   * (crew#552) The onboarding run this run was CHAINED from (a `capture-learnings` run the daemon
+   * launched when that onboarding completed) — read back from the `run.launched` entry after a
+   * restart. ABSENT on every other run. The live `/ws` frame is `runChained {session, from, workflow}`.
+   */
+  chained_from?: string;
+  /**
+   * (crew#854) `true` on a run an ASK launched (DES-ASK-TEAM-CHAT-001 §3: the chat's path), read back
+   * from the `run.launched` trail entry after a restart. ABSENT — never `false` — on any other run
+   * and on a daemon before the field.
+   */
+  ask_path?: true;
+  /**
+   * (crew#854) `true` while an ask path waits at its TURN gate: `awaiting_human` after an answer
+   * step, with no creator step on the run. The next message in the chat is the answer (it continues
+   * the path) — a skin draws no gate row and counts nothing as needing you. ABSENT otherwise: a
+   * gate at a creator or research step, or after Continue in Build, is a real gate.
+   */
+  ask_turn?: true;
   /**
    * 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
@@ -1413,6 +1432,30 @@ export interface CoreEvent {
  * named live, and a bundle assembled after a run cannot describe it in different
  * words than the operator watched it happen in. (FINDING-014)
  */
+/**
+ * The engine's ORPHAN frame (wicked-core `RunOrphaned`, core#124; named here additively for
+ * crew#830). Written to a run's durable event log at actor bootstrap for every session the store
+ * still calls `executing` that the new process restored no worker for — the daemon died mid-run.
+ * It is a REPORT, not a terminal: the run stays `executing` and resumable (`qe/acceptance.ts` keeps
+ * it out of the terminal set on purpose). A trail that ENDS on this frame is a run nobody is
+ * running; a live run's trail continues past it.
+ *
+ * The daemon acts on it at boot: every `executing` run whose trail ends on `runOrphaned` is resumed
+ * once through the engine's `resumeRun` (the same path as `POST /runs/:id/resume`) and the resume is
+ * recorded in the audit trail as `run.resumed` by the `daemon` actor with
+ * `detail: { via: 'boot', status, ord? }` — `via: 'boot'` is what tells it apart from an operator's
+ * manual resume (`detail: { status }`, actor = the caller).
+ */
+export type RunOrphanedFrame = {
+  type: 'runOrphaned';
+  /** The orphaned run's id. */
+  session: string;
+  /** The cursor unit's 1-based ord (the cursor position when the units could not be read). */
+  ord: number;
+  /** The remedy, spelled out: `POST /api/v1/runs/<id>/resume`. */
+  detail: string;
+};
+
 /**
  * The stall watchdog's DETECTION frame (crew#287; api-types 0.18.0 — previously daemon-local).
  * DAEMON-SYNTHETIC: broadcast straight to `/ws` when a run in `executing` has been silent on the
@@ -1482,9 +1525,12 @@ export type WorkerStallEscalatedFrame = {
    * `evaluating` — the worker returned and its gate evaluation is in flight, a reassign would start
    * a second creator; `evaluator_distinct` — every other seat is one evaluator ≠ creator forbids
    * (see `avoided`), so the unit was left for a human; `no_output` (outcome `exhausted`) — the
-   * reassigned seat produced nothing past a startup banner.
+   * reassigned seat produced nothing past a startup banner; `no_eligible_seat` (crew#833; additive)
+   * — every other seat is one this run BENCHED (see `benched`: quota exhausted, signed out — a seat
+   * the engine already failed over away from) or one evaluator ≠ creator forbids (see `avoided`),
+   * so the unit was left for a human rather than dispatched to a seat known to fail.
    */
-  reason?: 'tool_unit' | 'evaluating' | 'evaluator_distinct' | 'no_output';
+  reason?: 'tool_unit' | 'evaluating' | 'evaluator_distinct' | 'no_output' | 'no_eligible_seat';
   /**
    * The seats the failover pick excluded under evaluator ≠ creator (crew#638; additive): a
    * creator cursor avoids the run's evaluator seats, an evaluator cursor the seats that built its
@@ -1492,6 +1538,13 @@ export type WorkerStallEscalatedFrame = {
    * reassign that skipped one and on a `reason: 'evaluator_distinct'` notify; absent otherwise.
    */
   avoided?: string[];
+  /**
+   * The pool seats the failover pick excluded because THIS RUN benched them (crew#833; additive):
+   * `AgentSession.benched_seats` keys — a seat the engine failed over away from (quota exhausted,
+   * signed out, dead) is never a failover target in the same run. Present on an `ok` reassign that
+   * skipped one and on a `reason: 'no_eligible_seat'` notify; absent otherwise.
+   */
+  benched?: string[];
 };
 
 export interface RecordedEvent extends CoreEvent {
@@ -3071,6 +3124,14 @@ export interface SkillsManifestResponse {
    * `manifest.baseline`: different = Refresh baseline, then Publish.
    */
   installed?: InstalledPlugin | null;
+  /**
+   * Whether a `POST /skills/publish` is running on the daemon right now (crew#852; api-types
+   * 0.94.0) — its validate / hash / stage / lock run paced on the event loop, so this read answers
+   * while it runs, and `current` names the PREVIOUS generation until the publish commits and flips
+   * it (a reader sees the old generation or the new one, never half). A second publish in that
+   * window is the 2xx `publish-in-flight` envelope. Absent on a daemon older than 0.8.4.
+   */
+  publishing?: boolean;
 }
 
 /** `SkillsManifestResponse.installed` — the live plugin's identity (wicked-studio#388). */
@@ -4403,6 +4464,13 @@ export interface SystemSettings {
    * launches (those are always `'none'`).
    */
   deliverDefault?: 'pr' | 'none';
+  /**
+   * (crew#552) Whether a completed onboarding run chains a `capture-learnings` run for the same
+   * repo (filed in the onboarding run's project; proposals stay human-gated). Absent reads as
+   * `true`; `false` switches the chain off. A one-off opt-out is `autoCapture: false` on
+   * `POST /repos` / `POST /repos/:id/onboard`.
+   */
+  onboardingAutoCapture?: boolean;
   /**
    * The BASE skill every governed agent unit follows (crew#554 / wicked-core#468; additive): the
    * frontmatter name the daemon exports as the engine-config default `WICKED_BASE_SKILL_REF`, so
@@ -4435,6 +4503,16 @@ export interface SystemSettings {
    * `GH_TOKEN`; `GET /settings` returns this login and no secret ever.
    */
   deliverIdentityLogin?: string;
+  /**
+   * (crew#737) A PUSH IDENTITY PER REGISTERED REPOSITORY: repo id → the GitHub login its deliveries
+   * push as, winning over {@link deliverIdentityLogin}. The deliver phase reads that account's OWN
+   * gh token for the phase (`gh auth token --user`), so another tool switching gh's machine-wide
+   * active account mid-run does not change who pushes; an account gh is not signed in as is named
+   * on the deliver gate card before approval and refused by the phase. A repo absent (or `''`)
+   * falls back to the daemon-wide identity, else the CLI's active account. Logins only — never a
+   * token. `PUT /settings` replaces the whole map; `{}` clears it.
+   */
+  deliverIdentityByRepo?: Record<string, string>;
   /**
    * The stall watchdog's DETECTION threshold (crew#287; api-types 0.18.0 — previously a
    * daemon-local extension): minutes a run in `executing` may go without ANY engine event on the
@@ -4682,6 +4760,12 @@ export interface Project {
    * route boundary, so the wire carries ONE project shape. Always present on a read.
    */
   interactiveRoot?: string | null;
+  /**
+   * (crew#552) This project's override of the `onboardingAutoCapture` setting — whether a completed
+   * onboarding of a repo filed here chains `capture-learnings`. `null` ⇒ the daemon setting applies.
+   * Held crew-side like {@link interactiveRoot}; always present on a read.
+   */
+  autoCapture?: boolean | null;
   [k: string]: unknown;
 }
 
@@ -4728,6 +4812,8 @@ export interface UpdateProjectBody {
   /** DES-MERGE-001 §7.1 — bind this project to a wicked-interactive docs root.
    *  `null` clears the binding back to the shared default root. */
   interactiveRoot?: string | null;
+  /** (crew#552) Override `onboardingAutoCapture` for this project; `null` clears it back to the setting. */
+  autoCapture?: boolean | null;
 }
 
 /** `POST /projects/:id/members` body. */
@@ -4930,6 +5016,43 @@ export interface InteractiveStatusPosted {
   /** Wave 6: the unit (ord) the line narrates — the latest unit-scoped engine frame's `ord`, so a
    *  skin renders one council at a time. Absent before the first unit-scoped frame. */
   unit_ord?: number;
+  /**
+   * crew#512 (api-types 0.93.0): the document's repository grounding as data — present on exactly
+   * ONE frame per draft launch, the same `working` frame whose `message` is the "Grounded on …" /
+   * "Requested repository … skipped." narration (the text stays, for a skin that renders the
+   * transcript only). A skin keys a persistent header chip off this and never parses the sentence.
+   * Absent on every other frame, on a pre-0.93 daemon, and when the project has no repositories.
+   */
+  grounding?: InteractiveDocGrounding;
+}
+
+/**
+ * Where a document is grounded and why (crew#512; api-types 0.93.0) — the structured twin of the
+ * draft seam's "Grounded on …" narration (`groundingNarration`, doc-grounding.ts). Rides the one
+ * `InteractiveStatusPosted` frame that carries the narration and, once recorded, the document's
+ * `InteractiveDocSummary` row — the same object in both places, from the `crew-grounding.json`
+ * sidecar beside the document.
+ */
+export interface InteractiveDocGrounding {
+  /** Registry ids of the repositories the launch grounded on — the worker reads an offline snapshot
+   *  of each. `[]` = not repository-grounded (brief + code graph only). Names resolve through `GET /repos`. */
+  repo_refs: string[];
+  /** Why those: `named` — `repo_ref(s)` on the create request; `brief` — the brief names member repos;
+   *  `sole-member` — the project's only repository; `none` — nothing named, nothing inferred. */
+  source: 'named' | 'brief' | 'sole-member' | 'none';
+  /** Requested repositories that grounded nothing, with why (the narration's "skipped" clauses). */
+  skipped: InteractiveDocGroundingSkip[];
+  /** How many repositories the project has — the "1 of N" in a chip; `0` for a repo-less project. */
+  member_count: number;
+}
+
+/** One repository a launch did not ground on, as spelled on the request (or its registry id). */
+export interface InteractiveDocGroundingSkip {
+  ref: string;
+  /** `not-a-member` — not (or no longer) a project member; `ambiguous` — several members share that
+   *  name, the registry id disambiguates; `unsnapshotable` — a member whose offline snapshot failed
+   *  (too large, unreadable, …), so the task names it but the worker has no copy. */
+  reason: 'not-a-member' | 'ambiguous' | 'unsnapshotable';
 }
 
 // ── EP-C2: a document's checks — the four reviewers (api-types 0.88.0) ─────────────────────────
@@ -5013,6 +5136,14 @@ export interface InteractiveDocSummary {
   retired_at?: string;
   /** The crew project this row was listed under — the mount's `:projectId`. */
   projectId: string;
+  /**
+   * crew#512 (api-types 0.93.0): the repository grounding the draft seam resolved for this document,
+   * read from the `crew-grounding.json` sidecar beside it — the same object the launch's status
+   * frame carried, so a reopened document shows its chip without replaying the thread. Absent
+   * until a draft launch resolved it (a document still generating, one created before this release, an
+   * unfiled document) and on a pre-0.93 daemon.
+   */
+  grounding?: InteractiveDocGrounding;
 }
 
 /**
@@ -6245,7 +6376,10 @@ export interface GovernanceReplayOutcome {
   alreadyPresent: number | null;
   failed: number;
   dryRun: boolean;
-  /** The same-event conflation caveat the CLI prints, or `null`. */
+  /** The caveat the CLI prints, or `null`: on a dry run, that the outbox's untimestamped (pre-stamp) entries
+   *  cannot be ordered by a replay — they land in file order, and byte-identical unstamped lines share one
+   *  replay id (crew#829; `null` when every entry is stamped); on a real replay, the same-event conflation
+   *  caveat when entries were `alreadyPresent` and the outbox held unstamped lines. */
   note: string | null;
   /** Dry run only: the outbox fold (the `/diagnostics` dead-letter block minus the legacy pointer). */
   fold?: Omit<DiagnosticsGovernanceDeadletters, 'legacyOutbox'>;
@@ -7781,8 +7915,17 @@ export interface WatchFeedResponse {
    * `watch_finding.cleared` frames would: Fixed, Dismissed, rolled up). api-types 0.73.0.
    */
   cleared?: WatchFindingCleared[];
-  /** Present with `run=` only. */
+  /**
+   * Present with `run=` only. On an ENDED run (crew#828) an entry that saw nothing to judge says
+   * "nothing to check: …", never the in-progress "… yet".
+   */
   coverage?: WatchCoverage[];
+  /**
+   * (crew#828) With `run=` only, and only when the run ENDED having recorded no events at all (it ran
+   * before the checks existed, or ungoverned): ONE line for the whole coverage block, which a skin
+   * renders instead of the per-entry rows (each of those carries the same reason). ABSENT otherwise.
+   */
+  coverage_summary?: { state: 'no_evidence'; reason: string };
 }
 
 /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wicked-crew-api-types",
-  "version": "0.92.0",
+  "version": "0.95.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",