wicked-crew-api-types 0.100.0 → 0.101.0

package/index.d.ts

@@ -739,6 +739,32 @@ export interface WorkUnit {
   /** (crew#894) How that pool was seated, once distributed (see {@link UnitPoolSeating}). ABSENT
    *  for a pool of 1 and before distribution. */
   pool_seating?: UnitPoolSeating;
+  /**
+   * (wicked-core#761) The FAIL items an operator landed this Evaluator unit over at its
+   * `review_adjudication` gate, carried forward with the work. ABSENT when empty.
+   */
+  carried_items?: string[];
+  /**
+   * (wicked-core#686) The phase's AUTHORED instructions as a field: for the deliver phase, the gate
+   * card the workflow wrote. {@link WorkUnit.description} still carries them after ` ||| ` (it is
+   * the worker's prompt), but a reader takes them from here when
+   * {@link WorkUnit.structured_description} is true. ABSENT when the phase has none, and on a
+   * record that predates the field.
+   */
+  instructions?: string;
+  /**
+   * (wicked-core#686) Every approved intent amendment folded onto this unit, oldest first, as the
+   * operator's text (the description also carries each one after the amendment prefix).
+   * ABSENT when empty.
+   */
+  amendments?: string[];
+  /**
+   * (wicked-core#686) TRUE when the unit was planned with {@link WorkUnit.instructions} and
+   * {@link WorkUnit.amendments} as fields: read them there and never split the description.
+   * ABSENT (false) on a record that predates the fields; only then may a skin fall back to
+   * re-parsing the description, as a legacy path.
+   */
+  structured_description?: boolean;
 }
 
 /**
@@ -1285,7 +1311,10 @@ export interface GateDecision {
     | 'targeted'
     | 'accept_partial'
     | 'accept_suggestion'
-    | 'amend_intent';
+    | 'amend_intent'
+    /** (core#820) A `consent` gate's choice from its dry-run plan (`awaitingHuman.choices`), with
+     *  `approve: true`: `consent:worker` (the default), `consent:operator`, …; `reject` declines. */
+    | `consent:${string}`;
   /**
    * Where an approve's `amend` lands (api-types 0.38.0, additive; same release as `action`).
    * Absent = `'cursor'` (today: the gated unit's description). `'creator'` — the first creator
@@ -1377,6 +1406,24 @@ export interface CoreEvent {
    * ABSENT ⇒ nothing is preselected.
    */
   recommended?: number;
+  /**
+   * `awaitingHuman{gateKind: 'consent'}` (core#820): the answer tokens the gate offers, from the
+   * dry-run plan the gated unit depends on (`consent:<id>`…, `reject` last); `recommended` is then
+   * the index of the plan's default choice. ABSENT on every other gate, and on a consent gate with
+   * no plan (see `writeTargetsMissing`).
+   */
+  choices?: string[];
+  /** `awaitingHuman{gateKind: 'consent'}` (core#820): each token's label (`reject` → "Decline"). */
+  choiceLabels?: Record<string, string>;
+  /** `awaitingHuman{gateKind: 'consent'}` (core#820): what each token would write (`reject` → `[]`). */
+  writeTargets?: Record<string, ConsentWriteTarget[]>;
+  /** `awaitingHuman{gateKind: 'consent'}` (core#820): the ord of the dry-run unit the plan came from. */
+  writePlanOrd?: number;
+  /** `awaitingHuman{gateKind: 'consent'}` (core#820): CLIs the plan leaves out, and why. */
+  writeTargetsSkipped?: Array<{ cli: string; why: string }>;
+  /** `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;
   /** PTY terminal frames (`terminalOpened`/`terminalOutput`/`terminalExited`): the terminal id. */
   id?: string;
   /**
@@ -5366,6 +5413,9 @@ export interface InteractiveDocSummary {
   name: string;
   /** Manifest `kind`; a manifest without one lists as `doc`. */
   kind: 'doc' | 'html' | 'source' | 'demo';
+  /** Manifest `style` (the bridge's set: `web` | `ppt` | `brochure` | `doc`); ABSENT when the
+   *  manifest carries none (the bridge renders that as `web`). */
+  style?: 'web' | 'ppt' | 'brochure' | 'doc' | (string & {});
   /** Head version. */
   head: number;
   /** Lineage size. */
@@ -5436,6 +5486,16 @@ export interface InteractiveDocIndexRow {
   kinds: InteractiveSeamKind[];
   /** The governed runs those seams launched for it (ledger order) — the doc ↔ run binding. */
   runs: string[];
+  /** (crew#896) Manifest `style`, as the per-project list relays it; ABSENT when the manifest
+   *  carries none. */
+  style?: 'web' | 'ppt' | 'brochure' | 'doc' | (string & {});
+  /**
+   * (crew#896) The repository grounding the draft seam resolved for this document, read from the
+   * same `crew-grounding.json` sidecar the per-project list reads (see
+   * {@link InteractiveDocSummary.grounding}). ABSENT until a draft launch resolved it, and on a
+   * daemon before api-types 0.100.1.
+   */
+  grounding?: InteractiveDocGrounding;
 }
 
 /** A project docs root the listing could not read (api-types 0.36.0). */
@@ -5574,8 +5634,21 @@ export interface ChatScopeRepo {
   name: string;
   /** The registered root path — the read root the seats are pointed at. */
   rootPath: string;
+  /**
+   * (crew#899) What opening the chat found for this checkout against its upstream: `current`,
+   * `refreshed` (fast-forwarded `commits` to `upstream`, because the tree was clean and had no
+   * commits of its own), or `stale` (`behind` commits, NOT refreshed, `reason` says why; the seats
+   * are told). ABSENT when the root is not a checkout with an upstream, and on an older daemon.
+   */
+  freshness?: ChatCheckoutFreshness;
 }
 
+/** {@link ChatScopeRepo.freshness} (crew#899). */
+export type ChatCheckoutFreshness =
+  | { state: 'current'; upstream: string }
+  | { state: 'refreshed'; upstream: string; commits: number }
+  | { state: 'stale'; upstream: string; behind: number; reason: string };
+
 /**
  * What a chat's seats can see — decided at `POST /chats`, stated to the seats in their scratch
  * root's `AGENTS.md` / `CLAUDE.md`, and returned to the caller so the UI can show it. Additive:
@@ -8495,6 +8568,13 @@ export interface CatalogEntry {
   skill_ref: string | null;
   /** The entry's one-line description; `null` when it has none. */
   description: string | null;
+  /**
+   * (wicked-core#816) The entry's worker pool (`PhaseDef::pool_size()`): the most a plan step of
+   * this entry may ask for, since the planner refuses a raise as `pool_raised`; a step may only
+   * lower it. The engine always sends it (1 when the entry declares none). ABSENT from an engine
+   * before core-ts carries #816: read absent as 1.
+   */
+  pool?: number;
 }
 
 /** `GET /catalog`. */
@@ -9639,3 +9719,117 @@ export interface EditorGrantsResponse {
   firstParty: boolean;
   grants: EditorGrant[];
 }
+
+/** (core#820) One file or directory a consent choice would write, as the install's dry run
+ *  resolved it on the daemon host (`awaitingHuman.writeTargets`). */
+export interface ConsentWriteTarget {
+  path: string;
+  /** What the file is ("claude MCP config"). */
+  what: string;
+  /** The CLI it configures, when it is a CLI's file. */
+  cli?: string;
+  /** The path is the operator's OWN (outside every program-owned root). */
+  operatorOwned: boolean;
+}
+
+// ── Project aggregates (crew#371; GET /projects/:id/{requirements,domain,coverage}) ──────────────
+/** Each `crew.repo` member is one row, never dropped: `ok`, `absent` (nothing generated or indexed
+ *  yet), `error`, or `dangling` (a member whose registry record is gone). `reason` says why for
+ *  every state but `ok`. */
+export type ProjectAggregateRowState = 'ok' | 'absent' | 'error' | 'dangling';
+
+export interface ProjectAggregateRowBase {
+  repo: { id: string; name: string | null };
+  state: ProjectAggregateRowState;
+  reason?: string;
+}
+
+export interface ProjectAggregateTotals {
+  repos: number;
+  ok: number;
+  absent: number;
+  errors: number;
+  dangling: number;
+}
+
+/** One repo's part of `GET /projects/:id/requirements`. */
+export interface ProjectRequirementsRow extends ProjectAggregateRowBase {
+  /** Requirements matching the query in this repo (`0` unless `ok`). */
+  total: number;
+  /** This repo's whole corpus (`0` unless `ok`). */
+  corpus: number;
+  orphanedOverrides: number;
+  /** This repo's part of the requested window; `[]` when the window lies in other repos. */
+  items: RequirementSummary[];
+}
+
+/**
+ * `GET /projects/:id/requirements?q&risk&category&domain&offset&limit` (crew#371): the same query as
+ * `GET /repos/:id/requirements`, over every repo of the project. `offset`/`limit` (max 200) page a
+ * GLOBAL window over the repos in membership order; each row's `total` says how many of its
+ * requirements match. The synthesized `default` project has no members (empty rows).
+ */
+export interface ProjectRequirementsResponse {
+  projectId: string;
+  totals: ProjectAggregateTotals & { total: number; corpus: number };
+  offset: number;
+  limit: number;
+  rows: ProjectRequirementsRow[];
+}
+
+/** One domain of a repo's `requirements_graph.json`, summarised. */
+export interface ProjectDomainSummary {
+  name: string;
+  description: string | null;
+  requirements: number;
+  entities: number;
+}
+
+export interface ProjectDomainRow extends ProjectAggregateRowBase {
+  domains: ProjectDomainSummary[];
+}
+
+/** `GET /projects/:id/domain` (crew#371): per-repo domain summaries and the merged domain list.
+ *  Full graphs stay on `GET /repos/:id/domain-graph`; coverage is `GET /projects/:id/coverage`. */
+export interface ProjectDomainResponse {
+  projectId: string;
+  totals: ProjectAggregateTotals & { domains: number; requirements: number; entities: number };
+  merged: Array<{ name: string; repoIds: string[]; requirements: number; entities: number }>;
+  rows: ProjectDomainRow[];
+}
+
+export interface ProjectCoverageRow extends ProjectAggregateRowBase {
+  /** The repo's report WITHOUT `unaccounted_nodes` (their count is `unaccounted`; the list is on
+   *  `GET /governance/coverage?repo=`). `null` unless `ok`. */
+  report: Omit<CoverageReport, 'unaccounted_nodes'> | null;
+}
+
+/** `GET /projects/:id/coverage` (crew#371): each repo's own coverage report; `totals.coverage` is
+ *  sum(resolved) / sum(behavior_bearing) over the `ok` rows, `null` when that is 0/0. */
+export interface ProjectCoverageResponse {
+  projectId: string;
+  totals: ProjectAggregateTotals & { behavior_bearing: number; resolved: number; coverage: number | null };
+  rows: ProjectCoverageRow[];
+}
+
+// ── Product compose (crew#372; POST /projects/:id/product/compose) ──────────────────────────────
+/**
+ * Draft epics → features → stories from selected requirements of the project (at most 40). The
+ * daemon re-reads each one from its repo's artifact (an unknown or foreign ref is a 400 naming it,
+ * nothing launched) and launches a governed run through `POST /runs`: a `produce` draft step, then
+ * a `review` evaluator with a human gate; `deliver: "none"`. The draft ends with one fenced JSON
+ * plan `{epics:[{title, features:[{title, requirementRefs:[{repoId,key}], stories:[{title,
+ * acceptance:[…]}]}]}]}`. `POST /runs`' own refusals are relayed with their status.
+ */
+export interface ProductComposeBody {
+  requirements: Array<{ repoId: string; key: string }>;
+  /** The operator's steer for the draft (≤ 500 chars). */
+  instructions?: string;
+}
+
+/** `POST /projects/:id/product/compose` 202. */
+export interface ProductComposeResponse {
+  runId: string;
+  /** How many requirements the draft was handed. */
+  requirements: number;
+}

package/package.json

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