wicked-core-ts 0.7.43 → 0.7.45

package/index.d.ts

@@ -369,9 +369,13 @@ export declare class Core {
    * `{ source, reason, claim_id?, rule_ids?, denied_tool?, phase? }`. A rejected unit keeps its
    * PARTIAL output here, flagged; a unit denied BEFORE any output existed answers with an
    * explicit failure record (`output` absent, `denial` carrying the claim id / firing rule ids /
-   * denied tool) instead of `null`.
+   * denied tool) instead of `null`. (core#791) Every record also names its `attempt`, and
+   * `attempts` lists each attempt that left an output record; pass `attempt` to read that
+   * attempt's own bytes (`resolution: "superseded"` when a later attempt replaced it,
+   * `"unresolved"` when it ended without a resolution record — `phase_status` is then its step
+   * status, e.g. `timed_out`). Without `attempt` the resolution record is read as before.
    */
-  unitTranscript(unitId: string): Promise<string>
+  unitTranscript(unitId: string, attempt?: number | undefined | null): Promise<string>
   /**
    * A run's recorded event history, oldest first, as a JSON array. Each entry is the SAME tagged
    * object the `/ws` stream carries ([`CoreEvent::to_json`]) plus the durable log's envelope — a
@@ -661,17 +665,28 @@ export declare class Core {
    * engine round-trips the steering fields instead of silently dropping them.
    */
   steeringImport(batchJson: string): Promise<string>
+  /**
+   * What this host can contain, known before any run (core#678 item 1 — the boot probe,
+   * cached), as a JSON object: `{ platform, armed, tool: "sandbox-exec"|"bwrap"|null,
+   * reason: "no_launcher"|"cannot_arm"|null, reasonText, unsandboxedOptIn,
+   * verifyFloor: "contained"|"uncontained"|"refused" }`. `refused` means every check-running
+   * verify floor on this host will deny (no OS write boundary and no
+   * `WICKED_REPO_CHECKS_UNSANDBOXED=1`): crew's diagnostics and studio say so before a run.
+   */
+  hostBoundary(): Promise<string>
   /**
    * Governance rules eval — run an eval corpus through the REAL SELECT→DECIDE gate path and
    * score every sample (the engine seam behind crew's `POST /api/v1/testing/evals/run`).
-   * `args_json` is `{ type?, corpus?, knowledgeDb?, dbPath }` (camelCase keys are the PINNED
+   * `args_json` is `{ type?, corpus?, knowledgeDb?, memoryDb?, dbPath }` (camelCase keys are the PINNED
    * binding contract): `type` slices the corpus to one of the 7 steering types; `corpus`
    * names an estate knowledge scope (`evals:<name>` — a corpus landed by
    * [`Core::governance_corpus_import`]) or, omitted, selects the compiled-in default corpus;
    * `knowledgeDb` powers embedding gap hints (absent/unusable ⇒ the report carries
    * `degraded: "facet-only"` — an honest downgrade to keyword hints, never fabricated
-   * similarity); `dbPath` is the rules store, opened READ-ONLY — this call never goes through
-   * the single-writer actor and never writes either store.
+   * similarity); `memoryDb` (core#397) is the estate memory store the memory axis recalls from,
+   * opened READ-ONLY (absent ⇒ the report's `memory` is `null`, and a sample that declares
+   * memories rejects the run); `dbPath` is the rules store, opened READ-ONLY — this call never
+   * goes through the single-writer actor and never writes any store.
    *
    * Resolves to the `EvalReport` JSON exactly as the engine serializes it (snake_case — crew
    * passes it through verbatim as the pinned wire contract):
@@ -683,6 +698,10 @@ export declare class Core {
    * partitions the decide-lane rules eligible for the run (narrowed to `type` when given) by
    * whether any sample fired them; `recall_only` counts the effect-less rules the gate never
    * fires (core#395 — zero decide-lane rules means the verdicts are the corpus split).
+   * (core#397) The MEMORY axis: each result carries `memory: { surfaced, missing,
+   * unexpected_surfaced, verdict } | null` (null when the sample declares no memories), and the
+   * report carries `memory: { summary: { total, caught, gaps, false_positives }, coverage } |
+   * null` (null when no `memoryDb` was given) — both ALWAYS present, never absent.
    *
    * Fail-closed: malformed args, an unknown steering type, a corpus name outside the
    * `evals:` scope, or a missing store reject the Promise with the engine's reason — crew maps
@@ -1016,6 +1035,8 @@ export declare class Subscription {
  * `'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#810 (additive): unitDistributed.pool (UnitPoolSeatingJson | null — a phase's worker pool,
+ * one creator plus monitors, with any shortfall disclosed as requested/seated/missing).
  * core#461/#591 (additive): unitDistributed.distinctnessFallback ('creator_seat' |
  * 'same_cli_instance' | null — the evaluator ≠ creator fallback as a field, see
  * UnitDistributedEventJson); gateEscalated.condition
@@ -1073,10 +1094,25 @@ export declare class Subscription {
  * the very seat of) the CLI that created the work the unit depends on.
  * core#759 (additive): an awaitingHuman with `gateKind: 'team_dispute'` carries
  * `choices: ['approve', 'request_changes', 'reject']` and `recommended: 1` (send the finding
- * back). Every other gate kind carries NEITHER key (absent, never null).
+ * back). Every other gate kind carries NEITHER key (absent, never null), except a
+ * `consent` gate with a dry-run plan (core#820, below).
  * core#759 follow-up (additive): that team_dispute awaitingHuman also carries `findingIds`
  * (the unresolved HIGH finding ids the dispute is about, as `gate.opened` names them); absent
  * for every other gate kind.
+ * core#820 (additive): an awaitingHuman with `gateKind: 'consent'` whose gated unit depends on a
+ * dry-run plan carries `choices` (`'consent:<id>'` per plan choice, then `'reject'`), `recommended`
+ * (the default, program-owned choice), `choiceLabels` and `writeTargets` (both keyed by choice
+ * token; each target `{path, what, cli?, operatorOwned}`, `reject` → `[]`), `writePlanOrd` and,
+ * when the plan names any, `writeTargetsSkipped` (`{cli, why}[]`). With no plan it carries only
+ * `writeTargetsMissing` (why nothing is listed). Answer with `action: 'consent:<id>'`, approve
+ * (= the default) or reject.
+ * core#762 / core#418 (additive, new events): `acpTurnSettled` {session, ord, attempt, cliKey,
+ * quietSecs, outputBytes} — the bridge sent no stopReason for quietSecs after the worker's final
+ * message with no tool call open, so the ENGINE ended the turn and kept its output as the
+ * attempt's result (a watchdog seeing it does not reassign; WICKED_ACP_SETTLE_SECS, default 600,
+ * 0 = off). `acpProcessRestarted` {session, ord, attempt, cliKey, reason, ms} — the session that
+ * opened replaces one the engine closed itself (reason `posture_switch` |
+ * `fenced_unit_quiesced` | `turn_settled`); ms is the cold-start cost.
  */
 export interface CoreEventJson {
   type: string
@@ -1139,6 +1175,29 @@ export interface UnitDistributedEventJson extends CoreEventJson {
    * disclosure. The seat the unit stays on is therefore always a still-eligible one. Additive.
    */
   distinctnessFallback: 'creator_seat' | 'same_cli_instance' | null
+  /**
+   * (core#810) How the unit's worker POOL was filled — one creator plus `requested − 1` monitors
+   * from DISTINCT signed-in seat instances (never the creator's own, never the run's PA).
+   * `null` for a pool of 1 (the default) and a tool unit. A pool larger than what is signed in
+   * is seated SHORT and disclosed — never refused: `seated < requested`, `missing` names the
+   * configured instances that are not signed in, `shortfall` says why. Monitors watch an
+   * attempt only on a team run; any other unit reports `seated: 1` with the reason. Additive.
+   */
+  pool: UnitPoolSeatingJson | null
+}
+
+/** (core#810) {@link UnitDistributedEventJson.pool}: a unit's worker-pool fill. */
+export interface UnitPoolSeatingJson {
+  /** The phase's `pool` (after any plan step lowered it). */
+  requested: number
+  /** Seats filled: the creator plus `monitors.length`. */
+  seated: number
+  /** The monitor seat instances, in the order the team supervisor summons them. */
+  monitors: string[]
+  /** Configured instances that could have filled the shortfall but are not signed in. */
+  missing: string[]
+  /** Why `seated < requested`; `null` when the pool was filled. */
+  shortfall: string | null
 }
 
 /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wicked-core-ts",
-  "version": "0.7.43",
+  "version": "0.7.45",
   "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.43",
-    "wicked-core-ts-darwin-x64": "0.7.43",
-    "wicked-core-ts-linux-arm64-gnu": "0.7.43",
-    "wicked-core-ts-linux-x64-gnu": "0.7.43",
-    "wicked-core-ts-win32-x64-msvc": "0.7.43"
+    "wicked-core-ts-darwin-arm64": "0.7.45",
+    "wicked-core-ts-darwin-x64": "0.7.45",
+    "wicked-core-ts-linux-arm64-gnu": "0.7.45",
+    "wicked-core-ts-linux-x64-gnu": "0.7.45",
+    "wicked-core-ts-win32-x64-msvc": "0.7.45"
   },
   "devDependencies": {
     "@napi-rs/cli": "^2.18.4",