wicked-core-ts 0.7.30 → 0.7.33

package/index.d.ts

@@ -97,6 +97,23 @@ export interface LaunchOptions {
    * cost tools, not the run. Omit for the per-repo behaviour, unchanged.
    */
   projectGraph?: ProjectGraphOptions
+  /**
+   * (DES-TEAMING-002 T3; wicked-core-ts ≥ the release carrying seam T3) A USER-COMPOSED plan,
+   * as JSON: `{"steps":[{"catalog":"build"}, …], "touch"?: ["src/x.rs"], "override"?: {…}}`.
+   * The engine publishes `plan.proposed{by:"human"}`, scores it from `touch` (a creator plan
+   * with no `touch` scores 100, "no declared scope"), floor-fills and composes it into the run's
+   * `<run>:plan-1`, and pauses at a `plan_approval` gate when the approval matrix requires it —
+   * in manual mode always, in auto mode (`humanConfirm` omitted / `none`) when high risk.
+   * Mutually exclusive with `workflow` (a plan or a preset). A refused plan REJECTS the launch.
+   */
+  planJson?: string
+  /**
+   * (DES-TEAMING-002 §8.5, T3) The run DELIVERS: the launcher's `deliver` step as JSON — catalog
+   * `deliver`, id `deliver`, `executor: {type: "tool", cmd: [...]}` (crew's push-and-PR script).
+   * Only with `planJson` or a preset `workflow`: appended to the plan (unless it has its own
+   * `deliver` step) and put in the floor. Without a plan or preset the launch is REJECTED.
+   */
+  deliverStepJson?: string
 }
 /**
  * A handle to a wicked-core runtime. Construct with [`Core::spawn`] (production engine: real
@@ -119,6 +136,53 @@ export declare class Core {
    * as a JSON array of `AgenticCli` — pass straight into `launchRun`'s `clisJson`.
    */
   static registryRoster(): string
+  /**
+   * Whether this addon carries DES-TEAMING-002 T3's plan launch: `LaunchOptions.planJson` /
+   * `deliverStepJson` and `confirmGate(…, planJson)`. napi IGNORES an undeclared object field,
+   * so a launcher keys on this static's presence before it sends a plan — an older addon would
+   * drop the plan and run the launch unplanned and ungated.
+   */
+  static supportsPlanLaunch(): boolean
+  /**
+   * What this process's engine knows about its connection to the bus file at `path`
+   * (DES-TEAMING-002 T0 connection rule: one connection per bus file per process, opened by a bus
+   * thread, never closed): the JSON `{ "opens": <connections opened>, "opener": "<thread name>" }`,
+   * or `null` when the engine in this process never opened that file. An addon without this static
+   * predates the rule — crew's two-library stress suite keys on its presence.
+   */
+  static busConnectionStats(path: string): string | null
+  /**
+   * What arming the engine's launch bridge came to when this `Core` spawned (DES-TEAMING-002 T0),
+   * as JSON: `{ "state": "none" }` (no `WICKED_BUS_DB`), `{ "state": "armed", "floor": <event id> }`,
+   * or `{ "state": "not-armed", "reason": "…" }` — the bus did not open or answer within the arming
+   * bound, so this engine launches nothing from the bus. crew reports `not-armed` on
+   * `/health.warnings` (`bus.unavailable`).
+   */
+  busBridgeState(): string
+  /**
+   * Publish one event on this engine's bus (`WICKED_BUS_DB`), given as wicked-bus `emit()`
+   * takes it: JSON `{ event_type, domain, subdomain?, payload, idempotency_key?, producer_id?,
+   * ttl_hours? }`. Resolves to the row's `event_id`; a key already on the bus resolves to the
+   * existing row's id (where wicked-bus raises WB-002). Rejects with `WB-001 …` for an event
+   * wicked-bus would refuse (and for a field this emit does not write), and when the engine has
+   * no bus. Unlike wicked-bus `emit()`, it runs no schema registry or CAS offload and takes no
+   * causality fields (`correlation_id`, `session_id`, `parent_event_id`) from the environment
+   * (wicked-core#631: the engine is the one writer and the one SQLite library on its bus,
+   * so crew writes through here). Runs on the libuv pool over the engine's one bus connection;
+   * never through the actor.
+   */
+  busEmit(eventJson: string): Promise<number>
+  /**
+   * Read this engine's bus: live rows (`expires_at` in the future; every row when
+   * `includeExpired` — history readers) strictly after `afterId`,
+   * oldest first, whose `event_type` starts with `typePrefix` (a literal prefix; omitted = every
+   * type), at most `limit` of them (capped at 1000). Resolves to JSON `{ next, rows }`: `rows` are
+   * whole wicked-bus `events` rows with `payload` parsed; `next` is the cursor to pass back (the
+   * last row's id when the page is full, else the bus tail, `0` when `afterId` is past the tail
+   * — the bus file was replaced and its ids restarted). `limit` 0 reads no rows and resolves the
+   * tail as `next`. Rejects when the engine has no bus. Runs like `busEmit`.
+   */
+  busRead(afterId: number, limit: number, typePrefix?: string | undefined | null, includeExpired?: boolean | undefined | null): Promise<string>
   /**
    * EVENT nodes on the estate store at `dbPath` — the shared store the emit seam writes
    * governance events to (`WICKED_ESTATE_DB`; wicked-crew#495) — as a JSON number string, over
@@ -192,11 +256,12 @@ export declare class Core {
   chatSeats(chatId: string): Promise<string>
   /**
    * Every chat currently holding pool state — JSON array of
-   * `[{chatId, seats, idleSecs, cwd, codeGraphDb, readRoots}]`, sorted by id. `cwd` /
+   * `[{chatId, seats, idleSecs, cwd, codeGraphDb, readRoots, heldBy}]`, sorted by id. `cwd` /
    * `codeGraphDb` / `readRoots` are the scope recorded at `chatOpen` (wicked-core#410): where the
    * seats run, the estate graph their read-only estate MCP is bound to (`null` ⇒ none), and the
    * repository roots in scope (`[]` when none); `cwd` is `null` only for a pool entry whose scope
-   * is gone (a chat mid-close).
+   * is gone (a chat mid-close). `heldBy` lists the runs launched from the chat that keep it
+   * warm (`chatHold`, crew#619).
    *
    * Each warm seat pins an ACP bridge plus an agent child (~520 MB resident) and clients mint
    * chat ids freely, so without this an accumulation is invisible until the host runs out of
@@ -209,6 +274,13 @@ export declare class Core {
    * value that never meant a duration.
    */
   chatList(): Promise<string>
+  /**
+   * Hold a chat warm for a run launched from it (crew#619): the engine's idle reaper passes the
+   * chat over until that run is terminal, and its idle clock restarts then. Resolves `"true"`,
+   * or `"false"` when the chat is not open on this engine (nothing held). Call it right after
+   * `launchRun` resolves the run id.
+   */
+  chatHold(chatId: string, runId: string): Promise<string>
   /**
    * Close a chat's warm sessions (idempotent); emits
    * `chatClosed` with `reason: "requested"`.
@@ -237,8 +309,26 @@ export declare class Core {
    * the cursor unit (default) or the first creator phase at/after it. A disagreement
    * (`action=request_changes` with `approve=true`, `action=approve` with `approve=false`, an
    * unknown token) rejects before the engine is asked.
+   *
+   * (core#469 / core#467, additive.) Four more approve-shaped arms (`approve=true`, no `amend`
+   * / `amendScope`): `extend` | `targeted` | `accept_partial` answer the escalation gate of a
+   * repo-checks floor that did not finish (`repo_checks_timeout`) — the floor re-runs on the
+   * tree as it stands with 2× bounds, the targeted test set, or the unfinished checks waived —
+   * and `accept_suggestion` adopts the evaluator's discarded, pinned edit as the creator's
+   * amendment. The engine refuses each at any other gate.
+   *
+   * (core#555, additive.) `amend_intent` (`approve=true`, the text in `amend`, no `amendScope`)
+   * approves the gate AND AMENDS THE RUN'S INTENT: the text is appended to every unit at or after
+   * the cursor, so the acceptance list each LATER EVALUATOR is handed changes with the decision,
+   * and it is recorded on the run (`intent_amendments`) plus an `intentAmended` event. It is the
+   * only arm that can descope a run mid-flight; refused at a plan or team gate, and with no text.
+   *
+   * (DES-TEAMING-002 T3, additive.) `planJson` answers a `plan_approval` gate WITH AN EDIT: the
+   * edited plan as JSON (`approve=true`, `action` omitted or `edit_plan`). The engine accepts it
+   * as the next plan rev (floor phases added, never refused for being below the floor) or, if it
+   * refuses it, re-opens the gate with a new gate id.
    */
-  confirmGate(runId: string, approve: boolean, amend?: string | undefined | null, action?: string | undefined | null, amendScope?: string | undefined | null): Promise<string>
+  confirmGate(runId: string, approve: boolean, amend?: string | undefined | null, action?: string | undefined | null, amendScope?: string | undefined | null, planJson?: string | undefined | null): Promise<string>
   /**
    * Cancel a run — mark it terminally `Cancelled` and stop advancing it. Resolves to the status
    * token. Safe whether the run is executing or paused.
@@ -342,6 +432,101 @@ export declare class Core {
   registerRepo(name: string, rootPath: string): Promise<string>
   /** List every registered repository, as a JSON array of `RepoEntry` objects. */
   listRepos(): Promise<string>
+  /**
+   * Save a preset: a named phase selection over the catalog. `stepsJson` is a JSON array of
+   * plan steps (`{catalog, id, …step fields}`); `projectId` null ⇒ global, else that project's
+   * scope; `createdBy` defaults to `api`. Resolves to the stored `Preset` JSON object
+   * (`{ name, scope, steps, created_by, updated_at }`). Rejects with a message led by the
+   * reason token: `preset_invalid_name`, `preset_builtin_readonly`, `preset_reserved_created_by`,
+   * `preset_unknown_project`, `preset_invalid_steps` (then the catalog's step refusal).
+   */
+  putPreset(name: string, stepsJson: string, projectId?: string | undefined | null, createdBy?: string | undefined | null): Promise<string>
+  /**
+   * Delete a preset in its scope (`projectId` null ⇒ global). Resolves to the JSON literal
+   * `true`, or `false` when no such live preset exists there. Rejects `preset_builtin_readonly`
+   * for a built-in.
+   */
+  deletePreset(name: string, projectId?: string | undefined | null): Promise<string>
+  /**
+   * The presets a launch in `projectId` sees (null ⇒ the global set), sorted by name, as a JSON
+   * array of `Preset` objects: every global preset (built-ins included, `created_by: "builtin"`),
+   * with a project row replacing the global row of the same name.
+   */
+  listPresets(projectId?: string | undefined | null): Promise<string>
+  /**
+   * A team run's transport and its units' team snapshots — the persisted state behind crew's
+   * `GET /api/v1/runs/:id/team` — as JSON `{ runId, transport, reason, streamFloor, planRev,
+   * pending, units: [{ ord, transport, reason, ledgerSource, ledgerRef, finalPass, teamPause,
+   * findings }] }`. Per unit (the last four `null` until the unit's attempt folded):
+   * `ledgerSource` is where its ledger came from (`"folded"` by the supervisor, `"synthesized"`
+   * by the worker on the final-pass timeout, `"no_bus"`); `ledgerRef` is the supervisor row the
+   * gate read (`"ledger.folded#<ord>:<attempt>"`, `null` for a synthesized or local ledger);
+   * `finalPass` is the ledger's `final_pass` (`"completed"`, `"timed_out"`, `"skipped"`,
+   * `"stream_gap"`); `teamPause` true means an unresolved HIGH (or an incomplete record) stands
+   * without a council YES, so the run pauses `team_dispute` before the next dispatch;
+   * `findings` is how many findings the ledger holds. The run's `transport` is `"bus"`,
+   * `"none"` (un-teamed: render the "team transport unavailable" banner with `reason`),
+   * `"pending"` (not decided yet) or `"unavailable"` (teamed, but this daemon has no bus: the run
+   * is paused `team_transport` until the operator answers or a restart brings the bus back).
+   * Resolves to `"null"` for a run that is not a team run;
+   * rejects for an unknown run.
+   */
+  runTeam(runId: string): Promise<string>
+  /**
+   * Replay the team outbox (`<state home>/team-outbox.ndjson`) onto the bus: every lane in
+   * order, superseded lines skipped and compacted, idempotent (a line replayed twice lands
+   * once). Resolves to the JSON report `{ published: [[key, eventId]], superseded, invalid,
+   * remaining, failures: [[runId, reason]] }`; rejects when the engine has no bus or no state
+   * home. Runs off the actor.
+   */
+  replayTeamOutbox(): Promise<string>
+  /**
+   * The phase catalog (`src/catalog.rs`) for studio's phase picker, in catalog order, as a JSON
+   * array of `{ id, kind, role, gate, gate_type, executes_code, executor, validator_pin, pinned,
+   * evidence_floor, verified_evidence, skill_ref, description }` (`executor` is `"agent"` |
+   * `"tool"`; `pinned` = the entry carries a validator pin; `evidence_floor` = that pin is the
+   * evidence floor; `verified_evidence` = the entry declares re-verified evidence, so a step of it
+   * is an acceptance requirement of the run that contains it; `description` is `null` when the
+   * entry has none).
+   */
+  catalog(): Promise<string>
+  /**
+   * What a launch of `planJson` (`{ steps, touch?, override? }`) with `humanConfirm` on
+   * `repoRef` (the registered repo the launch would run on) with `deliverStepJson` (the
+   * launch's deliver step) would compute, persisting and publishing nothing — the launch's own
+   * precheck, intent score, floor fill, approval matrix and planning checks. `projectId` only
+   * matters to a preset name, so it does not change a plan's preview. For a behavioural touch
+   * set the score reads `repoRef`'s code graph at the base a launch would start from, read
+   * locally with NO fetch (the local remote-default tip, else HEAD).
+   * Resolves to JSON `{ score, deterministic, reasons, destructive, band, high_risk, floor,
+   * floor_override, steps, def, pauses, pause_reason, graph }`: `floor` is the floor phase
+   * types the plan owes; the steps the floor ADDED are the `steps` with `added_by: "floor"`
+   * (each with its `floor_reason`); `pauses` / `pause_reason` (`manual_mode` | `high_risk` |
+   * `override`) say whether the launch would pause at a `plan_approval` gate; `graph` is
+   * `"ready"` (the score read the repo's graph), `"not_needed"` (a docs-only touch set),
+   * `"unavailable"` (the fail-closed score: no repo, no or a stale graph) or `"pending_pa_scope"` (a
+   * creator plan with no touch set: the PA scopes it after launch, so the score is pending).
+   * Rejects with the launch's refusal (compose, supplied provenance, an override in auto mode,
+   * a planning check), an unregistered `repoRef` or one whose base cannot be resolved, or a bad
+   * `humanConfirm` / `deliverStepJson`.
+   */
+  previewPlan(planJson: string, projectId?: string | undefined | null, humanConfirm?: string | undefined | null, repoRef?: string | undefined | null, deliverStepJson?: string | undefined | null): Promise<string>
+  /**
+   * A mid-run plan edit (`POST /api/v1/runs/:id/plan`): `planJson` is `{ steps }`, the steps to
+   * ADD. Held and applied at the run's next step boundary through the engine's revision path
+   * (the ratchet and floor fill apply), which publishes `plan.proposed{by:"human", kind:"edit"}`
+   * then `plan.accepted{by:"human"}`: its author approved it, so no `plan_approval` gate opens
+   * for it (as for an edit at the gate). Idempotent by `requestId`.
+   * Resolves to JSON `{ proposal_id, duplicate, band, high_risk, floor_added }`: what the edit
+   * does to the run (the floor band and high-risk rule of the rev it makes, the floor phase
+   * types it adds), from the dry run it is validated by; `duplicate: true` = this request id was
+   * already taken (nothing new is held or published; `band` / `high_risk` null, `floor_added`
+   * empty). Rejects for an unknown, finished or un-planned run, a plan awaiting approval (edit
+   * it at the gate), a started deliver step, an edit the revision refuses, an empty request id,
+   * or an edit carrying `touch` / `override`. An edit still held when the run ends is refused
+   * on the bus (`plan.refused`).
+   */
+  proposePlan(runId: string, planJson: string, requestId: string): Promise<string>
   /**
    * Create a project. Resolves to the persisted `Project` as a JSON object
    * (`{ id, name, description, status, scope, created_at, updated_at }`). Rejects on an
@@ -596,6 +781,59 @@ export declare class Core {
    * array of `ConformanceRule` objects, severity-first then id.
    */
   recallRulesPreview(queryJson: string): Promise<string>
+  /**
+   * Judge and record ONE brokered MCP call (DES-MCP-TOOLS-001 §6 step 3; crew's broker calls
+   * this before it invokes anything). `request_json` is `{ token, call: { server, tool, args?,
+   * annotations?, classOverride?, registered, kind?, carrier? } }` — `token` is the worker's
+   * `WICKED_MCP_TOKEN`, the rest is the broker's registry resolution. Resolves to the verdict
+   * JSON `{ decision: "allow"|"ask"|"deny", subject, class, ruleIds, obligations, reason?,
+   * remedy?, claimId, unit: { runId, ord, attempt, phase, seat } }`; the decision is already
+   * recorded in the unit's decisions log. Rejects with `invalid_token: …`, `bad_request: …` or
+   * `guard_error: …` — every rejection is a refusal (a `guard_error` means the call could not be
+   * recorded, D-3: fail closed). Static: the token registry is process-global, so the broker
+   * needs no `Core` handle.
+   */
+  static evaluateMcpCall(requestJson: string): Promise<string>
+  /**
+   * The unit's visible MCP tool list (DES-MCP-TOOLS-001 §8 `GET /mcp/tools?token=`; slice S4,
+   * the garden shim's `list`). `request_json` is `{ token, calls: [{ server, tool, annotations?,
+   * classOverride?, registered, kind? }] }` — the worker's `WICKED_MCP_TOKEN` and the registry's
+   * tools. Each is judged for the token's unit with the SAME evaluation `evaluateMcpCall` runs,
+   * with no arguments, and NOTHING is recorded; a certain deny is left out. Resolves to
+   * `{ unit: { runId, ord, attempt, phase, seat }, tools: [{ subject, class, decision:
+   * "allow"|"ask", ruleIds, reason? }] }`. Rejects with `invalid_token: …`, `bad_request: …` or
+   * `guard_error: …`. Static, like `evaluateMcpCall`.
+   */
+  static listMcpTools(requestJson: string): Promise<string>
+  /**
+   * The MCP policy PREVIEW (DES-MCP-TOOLS-001 §4.7, §8 `POST /mcp/policies/preview`; slice
+   * S6): judge each call for each synthetic unit cell with the SAME evaluation
+   * `evaluateMcpCall` runs, over this Core's policy store, and record NOTHING. `request_json`
+   * is `{ calls: [{ server, tool, args?, annotations?, classOverride?, registered, kind? }],
+   * cells: [{ role: "creator"|"evaluator"|"recon", seat, mode: "ask"|"balanced"|"autonomous",
+   * phaseId? }] }`. Resolves to `[{ subject, cells: [{ role, seat, mode, phaseId?, decision,
+   * class, ruleIds, obligations, reason? }] }]`. Rejects with `bad_request: …` or
+   * `guard_error: …`.
+   */
+  previewMcpCalls(requestJson: string): Promise<string>
+  /**
+   * The ONE MCP tool class derivation (D-4): `annotations_json` is the tool's `tools/list`
+   * annotations object (or `null`), `class_override` an operator override (`read` | `write` |
+   * `destructive`). Returns the class; a tool with no annotations is `write`.
+   */
+  static mcpToolClass(annotationsJson?: string | undefined | null, classOverride?: string | undefined | null): string
+  /**
+   * The broker's OUTPUT decision for one brokered MCP call (DES-MCP-TOOLS-001 §6 step 8; crew's
+   * broker calls this after the upstream answered and the result was scrubbed). `request_json`
+   * is `{ token, call: { server, tool, args?, annotations?, classOverride?, registered, kind?,
+   * carrier? }, raw }` — the same call `evaluateMcpCall` judged, plus `raw`, the scrubbed result
+   * text (the output decision reads `raw` in place of the args). Resolves to `{ decision:
+   * "allow"|"deny", subject, ruleIds, reason?, remedy?, claimId? }`; a deny withholds the result
+   * and is already recorded as an advisory `mcp-deny:` claim, an allow records nothing. Rejects
+   * with `invalid_token: …`, `bad_request: …` or `guard_error: …` — every rejection is a refusal
+   * (withhold the result).
+   */
+  static evaluateMcpOutput(requestJson: string): Promise<string>
   /**
    * Front-half coverage gate report — JSON-serialized `CoverageReport`, or the JSON literal
    * `null` when the store has no domain-model nodes yet. Opens a read-only connection so it
@@ -753,8 +991,15 @@ export declare class Subscription {
  * entry carries `outcome`, `boundS`, `boundNote`, `failureIds`, `classification: 'regression' |
  * 'pre_existing_in_sandbox' | 'floor_env_mismatch' | null` (only a regression denies), `preExisting`,
  * `regressions` and `base: {head, cached, run, error} | null` (the same check run on the run base).
- * core#461 (additive): unitDistributed.distinctnessFallback ('creator_seat' | null — the
- * evaluator ≠ creator fallback as a field, see UnitDistributedEventJson); gateEscalated.condition
+ * core#481/#546/#553 (additive): `classification` gains `'env_cannot_run'` (every failure carries the
+ * nested-sandbox launcher signature on both trees) and `'flaky_under_load'` (a head-only set of ≤ 2
+ * that passed an isolated re-run) — neither denies; equal failure sets are now
+ * `'pre_existing_in_sandbox'` (`'floor_env_mismatch'` is no longer produced); libtest ids are
+ * qualified by binary (`test t::name [-p crate --lib]`); every `checks[]` entry carries
+ * `envCannotRun: string[]` and `reruns: CheckRun[]` (each re-run's `boundNote` carries the host load).
+ * core#461/#591 (additive): unitDistributed.distinctnessFallback ('creator_seat' |
+ * 'same_cli_instance' | null — the evaluator ≠ creator fallback as a field, see
+ * UnitDistributedEventJson); gateEscalated.condition
  * gains the class 'dead_seat' (denialSource 'dead_seat'): a worker exited on a dead-seat refusal
  * (signed out / quota / not installed) and no eligible seat remains — the attended run pauses at
  * the escalation gate instead of failing.
@@ -764,6 +1009,16 @@ export declare class Subscription {
  * gains `rework_amendment` (string | absent) — the full findings+note text stored at request_changes
  * so the creator's re-dispatch receives the amendment whole, never capped; unitContextInjected's
  * `outputBytes` per item reflects the full amendment byte length.
+ * DES-TEAMING-002 T6 (removal): the DES-001 team events unitCheckpoint, monitorAttached,
+ * monitorFinding, adviceDelivered and workerAdviceResponse are no longer emitted. Team
+ * communication is the `wicked.team.*` bus stream (crew relays it as `teamEvent` frames).
+ * core#416 (no shape change, a new VALUE): repoChecksEvaluated.sandboxLevel — and the same field
+ * on `env` — can now read `'none'`, beside 'sandboxed' | 'network-only' | 'best-effort'. It means
+ * the repository's own check scripts RAN with no OS write boundary, on the operator's explicit
+ * `WICKED_REPO_CHECKS_UNSANDBOXED=1` opt-in (the hosts where none can be armed: Windows, a Linux
+ * box without `bwrap`). The check results are real; a consumer folding enforcement must read
+ * 'none' as UNENFORCED containment, never as a contained pass. 'best-effort' still means the
+ * checks did NOT run.
  */
 export interface CoreEventJson {
   type: string
@@ -786,9 +1041,11 @@ export interface UnitDistributedEventJson extends CoreEventJson {
   ord: number
   /** The roster key of the assigned seat. */
   cli: string
-  /** How the seat was chosen: the council verdict, a degrade to the first candidate, an
-   * evaluator ≠ creator reassignment, or a deterministic tool execution. */
-  routingMethod: 'council' | 'degraded' | 'evaluator_distinct' | 'tool'
+  /** How the seat was chosen: `'teamed'` — the deterministic pick, no council (core#590 S5,
+   * what every seated unit gets now) — an evaluator ≠ creator reassignment, or a deterministic
+   * tool execution. `'council'` and `'degraded'` are no longer emitted by a new run; they stay
+   * in the set because a recorded run's replayed frames carry them. */
+  routingMethod: 'council' | 'degraded' | 'evaluator_distinct' | 'tool' | 'teamed'
   agreementPct: number | null
   returned: number | null
   /** Seats convened for the council that produced this assignment (`null` = unknown). */
@@ -804,13 +1061,26 @@ export interface UnitDistributedEventJson extends CoreEventJson {
    */
   seatConstraint: string | null
   /**
-   * (core#461) The evaluator ≠ creator DISCLOSURE as a field: `'creator_seat'` when a review/test
-   * unit STAYS on a seat that built what it checks because no eligible seat distinct from the
-   * builders admits it — a single-eligible-seat roster, or a bench that emptied the pool
-   * (`degradedReason` then says which). `null` otherwise. The fallback seat is always a
-   * still-eligible one: a benched or dead seat is never the fallback. Additive.
-   */
-  distinctnessFallback: 'creator_seat' | null
+   * (core#461, core#591) The evaluator ≠ creator DISCLOSURE as a field. `null` when there is
+   * nothing to disclose. Two values:
+   *
+   * - `'creator_seat'` — a review/test unit STAYS on a seat that built what it checks because no
+   *   eligible seat distinct from the builders admits it.
+   * - `'same_cli_instance'` — the unit IS on a seat distinct from every builder seat, but that
+   *   seat runs the SAME cli as a builder (`claude#2` grading `claude#1`: two seat INSTANCES of
+   *   one cli). Instance distinctness removes the creator's CONTEXT, not the model's blind spots
+   *   — same weights, same failure modes. Read it as a model-distinct evaluator and you are
+   *   accepting a degraded gate, so it is on the wire. `'creator_seat'` dominates when both
+   *   would apply.
+   *
+   * The paragraph below is about `'creator_seat'` only. The roster is always BENCH-FREE when it
+   * is set (core#560/#567): a bench that leaves a review/test unit no distinct seat REFUSES the
+   * plan instead, so that case never reaches the wire. Three shapes set it — a one-seat roster; a
+   * roster whose every seat was assigned a Build/Recon unit; and one whose only non-builder seats
+   * the unit's skills refuse. `degradedReason` does NOT name either value: the field is the
+   * disclosure. The seat the unit stays on is therefore always a still-eligible one. Additive.
+   */
+  distinctnessFallback: 'creator_seat' | 'same_cli_instance' | null
 }
 
 /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wicked-core-ts",
-  "version": "0.7.30",
+  "version": "0.7.33",
   "description": "Node/TypeScript bindings (napi-rs) for wicked-core: drive the in-process orchestration engine from JS/TS.",
   "license": "MIT",
   "repository": {
@@ -43,11 +43,11 @@
     "typecheck": "tsc --noEmit -p types-test/tsconfig.json"
   },
   "optionalDependencies": {
-    "wicked-core-ts-darwin-arm64": "0.7.30",
-    "wicked-core-ts-darwin-x64": "0.7.30",
-    "wicked-core-ts-linux-arm64-gnu": "0.7.30",
-    "wicked-core-ts-linux-x64-gnu": "0.7.30",
-    "wicked-core-ts-win32-x64-msvc": "0.7.30"
+    "wicked-core-ts-darwin-arm64": "0.7.33",
+    "wicked-core-ts-darwin-x64": "0.7.33",
+    "wicked-core-ts-linux-arm64-gnu": "0.7.33",
+    "wicked-core-ts-linux-x64-gnu": "0.7.33",
+    "wicked-core-ts-win32-x64-msvc": "0.7.33"
   },
   "devDependencies": {
     "@napi-rs/cli": "^2.18.4",