wicked-core-ts 0.7.40 → 0.7.42

package/index.d.ts

@@ -255,59 +255,6 @@ export declare class Core {
   subscribe(callback: (err: Error | null, eventJson: string) => void): Subscription
   /** Liveness probe — emits a `Heartbeat` to subscribers and resolves once the actor acks (`"ok"`). */
   ping(): Promise<string>
-  /**
-   * Open a chat: eagerly warm one ACP session per seat (crew#165 / core#13) in a SCOPE
-   * (wicked-core#410 / wicked-crew#502). `cwd` is the seats' working directory — the chat's
-   * scratch root; omitted, a private `<tmp>/wicked-core-chat-<id>` of the chat's own, NEVER this
-   * process's cwd. `scopeJson` is `{"codeGraphDb"?: string|null, "readRoots"?: string[]}`: the
-   * estate graph the seats' READ-ONLY estate MCP is bound to (omitted/null ⇒ no estate MCP) and
-   * the repository roots in scope (advertised to a claude seat as `additionalDirectories`,
-   * recorded for every seat). Resolves to a JSON array of per-seat outcomes
-   * `[{cliKey, ok, error?}]`; `chatSessionReady`/`chatSessionFailed` also stream to
-   * subscribers. Blocking handshakes run on the task pool, not the JS thread.
-   */
-  chatOpen(chatId: string, clisJson: string, cwd?: string | undefined | null, scopeJson?: string | undefined | null): Promise<string>
-  /**
-   * Fan a message out to the chat's warm seats (all, or `targets_json` subset). Ack-fast:
-   * resolves to the JSON array of seats targeted; replies stream as `chatDelta`/`chatReply`.
-   * `cwd` is accepted for wire compatibility and IGNORED (wicked-core#410): every turn runs in
-   * the scope recorded at `chatOpen` — a per-message working directory was the F-067 leak.
-   */
-  chatSend(chatId: string, text: string, targetsJson?: string | undefined | null, cwd?: string | undefined | null): Promise<string>
-  /** The seats currently warm for a chat — JSON array of cli keys. */
-  chatSeats(chatId: string): Promise<string>
-  /**
-   * Every chat currently holding pool state — JSON array of
-   * `[{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). `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
-   * memory (FINDING-027). `idleSecs` is seconds since the chat's last open/ensure/turn, or
-   * `null` when no activity was ever recorded — which the reaper treats as idle-since-forever.
-   *
-   * `null` rather than the `u64::MAX` the Rust side uses for that case: a JS `number` is an
-   * f64, so `u64::MAX` arrives as `18446744073709552000` and no consumer can test for the
-   * sentinel by equality. `null` is checkable, and it stops a caller from doing arithmetic on a
-   * 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"`.
-   */
-  chatClose(chatId: string): Promise<string>
   /**
    * Launch an interactive, resumable run: plans + distributes, then executes each unit off-thread
    * (or pauses at a human-confirm gate). Resolves to the run id. Progress arrives as `CoreEvent`s
@@ -340,10 +287,10 @@ export declare class Core {
    * 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.
+   * 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 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 empty 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
@@ -796,6 +743,19 @@ export declare class Core {
    * call; no process restart required.
    */
   registerWorkflow(json: string): Promise<string>
+  /**
+   * (core#677) Vault a deterministic validator the host authored — `criterion` and a POSIX
+   * shell `script` that exits 0 iff it holds — UNAPPROVED, resolving to its content-addressed
+   * pin. Rejects `bad_request: …` on an empty criterion/script or a script the run-time
+   * backstop refuses. Approve it with `approveValidator`; a def pins the APPROVED pin.
+   */
+  vaultValidator(criterion: string, script: string): Promise<string>
+  /**
+   * (core#677) Approve a vaulted validator (the audited step) and resolve to the APPROVED pin
+   * a workflow def's `validator_pin` names. Rejects `not_found: …` on an unknown pin. A def
+   * pinning an unapproved or unvaulted pin still fails its launch at plan time.
+   */
+  approveValidator(pin: string): Promise<string>
   /**
    * Recall which conformance rules apply to the given `query_json` (a JSON-serialized
    * `RuleQuery` — fields: language, layer, framework, severity, rule_type, steering_type;
@@ -829,6 +789,15 @@ export declare class Core {
    * needs no `Core` handle.
    */
   static evaluateMcpCall(requestJson: string): Promise<string>
+  /**
+   * (core#669, DES-MCP-TOOLS-001 decision 2) Record that a brokered REST call left its pinned
+   * host (crew's broker calls this on `RestBoundaryError`, after `evaluateMcpCall` allowed it).
+   * `request_json` is `{ token, subject, reason }`; appends a unit-FATAL deny claim under rule
+   * `engine:mcp-rest-boundary` (not the advisory `mcp-deny:` class) and resolves to
+   * `{ claimId }`. Rejects with `invalid_token: …`, `bad_request: …` or `guard_error: …` — the
+   * broker then refuses the call with `guard_error` (D-3). Static, like `evaluateMcpCall`.
+   */
+  static recordMcpBoundaryEscape(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?,
@@ -946,6 +915,9 @@ export declare class Core {
    * `newCli` is either a CLI key string (re-dispatch immediately to that CLI) or `null` (re-run
    * the council and let it pick). Returns `"ok"` when the command has been queued; the
    * [`CoreEvent::UnitReassigned`] event confirms the reassignment.
+   *
+   * (core#773) On a run parked at a gate, a named `newCli` re-seats the cursor unit without
+   * dispatching it (the attempt does not move); approving the gate then runs it once, there.
    */
   reassignUnit(runId: string, ord: number, newCli?: string | undefined | null): Promise<unknown>
 }
@@ -1013,8 +985,9 @@ export declare class Subscription {
  * may start with 'install fence:' (a package-manager install outside the unit's worktree, judged
  * from the seat's shell cwd tracked across its tool calls — best-effort, never hermetic);
  * sandboxPosture {session, ord, cli, posture: 'os' | 'advisory', reason} (the write containment
- * the assigned seat runs under — 'advisory' = no OS write boundary on the seat record, command-text
- * fences + worktree guard only); worktreeRetained {session, path, reason} (a terminal run's worktree
+ * the assigned seat runs under — 'os' = the seat is on the OS-sandbox floor, the run is bound to a
+ * worktree and the host launcher arms; 'advisory' = one of the three failed, reason names which —
+ * command-text fences + worktree guard only); worktreeRetained {session, path, reason} (a terminal run's worktree
  * kept because it holds uncommitted work — cancel included).
  * core#468 (additive): unitDispatched carries `baseSkill: {name, role, handed} | null` — the run's
  * role-keyed BASE skill directive (`role` is 'creator' | 'evaluator' | 'neutral'), null when the
@@ -1082,6 +1055,22 @@ export declare class Subscription {
  * the option the producer of the options recommends (the field's own JSON Schema `default`, when
  * it names a delivered option). ABSENT ⇒ nothing is preselected; `options`/`propType` stay
  * explicit nulls.
+ * core#412 (additive — a new `type` value): cliUsageUnreported {session, ord, attempt, cli} — an
+ * agent unit whose seat reported NO usage for that attempt; emitted where cliUsage would be, so a
+ * burn view shows the unit as UNREPORTED, never as $0.
+ * core#554 (additive): every unitContextInjected.priorUnits[] item carries `deliveredBytes`
+ * (the size the worker received, after the carriers' shared prior-context clip) and `clipped`
+ * (boolean). `outputBytes` stays the pre-clip size; a clipped operator note now says so.
+ * core#651 (a new VALUE): unitReworkAmended.scope can read `'floor_auto_retry'` — the one automatic
+ * round a creator gets when its own repo-checks floor ran and failed (the failing tails are the
+ * amendment); WorkUnit gains `floor_auto_retries` (number, absent while 0).
+ * core#686 (additive): WorkUnit gains `instructions` (the phase's authored card, absent when
+ * none), `amendments` (approved intent-amendment texts, absent when empty) and
+ * `structured_description` (true on units planned with those fields; absent on older records,
+ * which a reader re-parses from `description` as legacy).
+ * core#591 (additive): unitReassigned carries `distinctnessFallback` ('creator_seat' |
+ * 'same_cli_instance' | null), as unitDistributed does — the new seat is another INSTANCE of (or
+ * the very seat of) the CLI that created the work the unit depends on.
  */
 export interface CoreEventJson {
   type: string

package/package.json

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