wicked-crew-api-types 0.133.0 → 0.135.0

package/index.d.ts

@@ -739,6 +739,12 @@ export interface WorkUnit {
   /** (api-types 0.102.0; wicked-core#850, core-ts ≥ 0.7.46) The receipt of this unit's LAST gate,
    *  as `gateEvaluated.assurance` carried it. ABSENT until a gate ran, and on an older engine. */
   assurance?: AssuranceReceipt;
+  /** (api-types 0.135.0) Every layer other than the repo-checks floor that denied this unit's last
+   *  gate, plus any earlier denial over the same tree that gate did not ask again — the record
+   *  `operator_judgment` reads (it is refused while any stands). `[]`: known, nothing but the floor
+   *  denied. ABSENT (or `null`): unknown — a unit from before the record, or an older engine. The
+   *  engine's own serialization, so its fields are snake_case (`claim_id`, `rule_ids`, …). */
+  denials_behind?: Array<{ source: string; reason: string; [k: string]: unknown }> | null;
   /** Evaluator≠creator role. Present on def-driven units; absent on legacy/free-text. */
   role?: PhaseRole;
   /** Gate policy for this phase. Present on def-driven units; absent on legacy/free-text. */
@@ -1605,6 +1611,34 @@ export interface GateInfo {
    *  work this gate asks about. `null` when the unit carries none (no gate evaluated it yet, or an
    *  older engine); ABSENT on an older daemon. */
   assurance?: AssuranceReceipt | null;
+  /**
+   * (api-types 0.134.0) On a gate whose unit no judge could rule on (`denial.source:
+   * 'judge_unavailable'`): whether its JUDGE CAN BE RE-RUN NOW — `{approve: true, action:
+   * 'rejudge'}` ({@link GateDecision.action}) — and which seats the engine's judge selection would
+   * draw from. ABSENT on every other gate, on an older daemon, and on an engine without the
+   * readiness read (then `rejudge` is not offered).
+   */
+  rejudge?: RejudgeOffer;
+}
+
+/**
+ * (api-types 0.134.0) Whether a `judge_unavailable` gate's judge can be re-run now. `available` —
+ * the engine's judge selection names at least one seat (`eligible`, rotation order, fallback judges
+ * last): `rejudge` re-arms the judge on the same work (the step does not run again; deny-dominates
+ * still folds the result). Otherwise `missing` says which of the run's seats cannot judge this work,
+ * and why — what to fix before re-running it.
+ */
+export interface RejudgeOffer {
+  available: boolean;
+  eligible: string[];
+  missing: RejudgeMissingSeat[];
+}
+
+/** One run seat that cannot judge the gated work now, and why, in the engine's words (`built this
+ *  work`, `benched for this run: quota_exhausted …`, `not usable now: signed out`). */
+export interface RejudgeMissingSeat {
+  seat: string;
+  reason: string;
 }
 
 /**
@@ -1669,6 +1703,28 @@ export interface GateDecision {
     | 'accept_partial'
     | 'accept_suggestion'
     | 'amend_intent'
+    /** (api-types 0.134.0) RE-RUN THE JUDGE of a `judge_unavailable` gate, with `approve: true` and
+     *  nothing else: the engine re-arms the judge on the same work with the run's roster as it
+     *  stands now (never the work's authors or the pinned validator's author), records
+     *  {@link JudgeRerunRequestedEvent} and re-dispatches the unit WITHOUT running its seat; the
+     *  ordinary fold judges the result, so a REJECT, a failed floor or another seatless judge denies
+     *  again. Refused (409, gate left open) at any other gate and when no judge seat is eligible —
+     *  {@link GateInfo.rejudge} says beforehand. Unlike a plain approve there, it is never the
+     *  operator's own judgment. */
+    | 'rejudge'
+    /** (api-types 0.135.0, operator ruling 2026-10-21) APPROVE AS YOUR OWN JUDGMENT at the
+     *  escalation gate of a FAILED REPO-CHECKS FLOOR (`gateEscalated.condition: 'floor_failed'`,
+     *  `denialSource: 'repo_checks' | 'repo_checks_timeout'`), with `approve: true` and the written
+     *  rationale in `amend` — required, non-empty (a 400 otherwise); no `amendScope` or `plan`. The
+     *  operator judges from the evidence that the failures are not the work's (load flakes,
+     *  pre-existing reds): the unit counts as it stands, its gate receipt records an
+     *  {@link OperatorJudgment} with `floorOverride` set (the floor result it overrode, labelled
+     *  "floor overridden by operator"), and the run ({@link RunAssurance.floorOverrides}) and the
+     *  delivery carry the label. It overrides the floor ONLY: the engine refuses it (409, gate left
+     *  open) when any other layer of the same gate also denied, on a team member's step, on a tool or
+     *  deliver step and at every other gate. QE acceptance is never waived by it — a run that
+     *  requires it still needs its PASS before delivery. Engine: wicked-core-ts after 0.15.6. */
+    | 'operator_judgment'
     /** (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}`;
@@ -2230,7 +2286,8 @@ export interface DataUsedEvent {
  *   names the error. Before core-ts 0.7.46 the error was dropped and the gate could approve.
  * - `judge_unavailable` — the gate's judge did not run (every eligible judge seat failed, or, since
  *   core-ts 0.7.46 / EX-02, the run requires a judge and none distinct from the creator existed).
- *   A HOLD: sign a judge seat in, then approve to re-run.
+ *   A HOLD: approve = the operator's own judgment (labelled "judged by operator"); once a judge seat
+ *   can rule, `rejudge` re-runs the judge (api-types 0.134.0, {@link GateInfo.rejudge}).
  * Open-ended (`string & {}`) so a newer engine's source parses in an older studio.
  */
 export type UnitDenialSource =
@@ -2279,7 +2336,8 @@ export type AssuranceInstrument =
   | 'judge'
   | 'evaluator_pass'
   | 'distinct_evaluator'
-  /** (api-types 0.110.0) The operator judged a gate whose judge could not rule. */
+  /** (api-types 0.110.0) The operator judged a gate whose judge could not rule — or (api-types
+   *  0.135.0) overrode a failed repo-checks floor (`operatorJudges[].floorOverride`). */
   | 'operator_judge'
   | (string & {});
 
@@ -2292,9 +2350,34 @@ export interface OperatorJudgment {
   by: string;
   /** Unix millis. */
   at: number;
+  /** The operator's note; on a floor override, the written rationale (never empty). */
   note: string | null;
-  /** Why the judge could not rule (the gate's denial reason). */
+  /** Why the judge could not rule (the gate's denial reason) — or, on a floor override, why the
+   *  floor denied. */
   reason: string | null;
+  /** (api-types 0.135.0) Set when this judgment OVERRODE a failed repo-checks floor
+   *  ({@link GateDecision.action} `'operator_judgment'`); ABSENT on a judge-unavailable judgment
+   *  and on an older engine. */
+  floorOverride?: FloorOverride;
+}
+
+/**
+ * (api-types 0.135.0, operator ruling 2026-10-21) The failed floor result an operator's judgment
+ * overrode. It answers the repo-checks floor only: every other layer of the gate still denies, and
+ * QE acceptance is untouched.
+ */
+export interface FloorOverride {
+  /** The floor layer that denied: `repo_checks` | `repo_checks_timeout`. */
+  layer: string;
+  /** The floor result overridden — `<run>:unit-<ord>:attempt-<n>:<layer>`, the unit's
+   *  `repoChecksEvaluated` frame for that attempt (or the carried result it stood on). */
+  resultId: string;
+  ord: number;
+  attempt: number;
+  /** The tree the overridden checks ran on, when the report names it. */
+  tree: string | null;
+  /** `floor overridden by operator` — the line to show as-is. */
+  label: string;
 }
 
 /**
@@ -2337,8 +2420,14 @@ export interface RunAssurance {
    *  exactly when `required` holds `qe_acceptance`. ABSENT on an older engine (then a required
    *  `qe_acceptance` is enforced). */
   qe?: QeAcceptanceDecision;
+  /** (api-types 0.135.0) Every failed floor the operator overrode on this run ("floor overridden
+   *  by operator"), each with who, when and the rationale; ABSENT when none or on an older engine. */
+  floorOverrides?: OperatorJudgment[];
 }
 
+/** (api-types 0.135.0) The label an overridden floor carries on the run, the gate and the delivery. */
+export type FloorOverrideLabel = 'floor overridden by operator';
+
 /** (api-types 0.106.0) `QeAcceptanceDecision.status`. */
 export type QeAcceptanceStatus = 'required' | 'waived' | 'skipped' | (string & {});
 
@@ -3180,6 +3269,22 @@ export type QeAcceptanceDecidedEvent = {
   qe: QeAcceptanceDecision;
 };
 
+/** (api-types 0.134.0) The operator re-armed the judge of a `judge_unavailable` gate
+ *  ({@link GateDecision.action} `rejudge`): attempt `attempt` re-reads attempt `fromAttempt`'s
+ *  captured output with a judge drawn from `seats` (eligible when it was armed); the step's seat does
+ *  not run. Emitted before `resumed`; that attempt's `gateEvaluated` says what the judge ruled.
+ *  `type` alias on purpose. */
+export type JudgeRerunRequestedEvent = {
+  type: 'judgeRerunRequested';
+  session: string;
+  ord: number;
+  attempt: number;
+  fromAttempt: number;
+  seats: string[];
+  previousReason: string;
+  by: string;
+};
+
 /** The gate-evidence events (wicked-core F-036/F-039, extended by wicked-core#431 — api-types 0.33.0
  *  added {@link WorktreeRestoredEvent}, {@link DeliverLiftEvaluatedEvent} and
  *  {@link EvaluatorToolCallDeniedEvent}) as a discriminated union for consumers that narrow on `type`;

package/package.json

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