wicked-core-ts 0.7.18 → 0.7.19

package/index.d.ts

@@ -103,6 +103,26 @@ export declare class Core {
    * as a JSON array of `AgenticCli` — pass straight into `launchRun`'s `clisJson`.
    */
   static registryRoster(): 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
+   * a READ-ONLY connection (never the single-writer actor's handle; the store must already
+   * exist). crew's `GET /diagnostics` reports it as `governance.records.total` and derives
+   * `sinceBoot` from a boot baseline; an addon without this static answers `null` there.
+   */
+  static eventStoreCount(dbPath: string): Promise<string>
+  /**
+   * Replay a dead-letter outbox — the emit seam's NDJSON spool (`WICKED_APPS_EMIT_DEADLETTER`)
+   * of governance events it could not store — into the estate store at `dbPath`, writing each
+   * record as the EVENT node it should have been with its original `ts` restored
+   * (`wicked_apps_core::emit::replay_outbox`). Opens the store read-write (creating it if
+   * missing — the caller creates the parent directory). IDEMPOTENT: a replayed node's id is the
+   * spool line's content hash plus its original stamp, so the same line replayed twice lands
+   * once. Resolves to the JSON report `{ read, replayed, already_present, failed: [{ line,
+   * reason }] }`; a failed entry carries its ORIGINAL line so the caller can keep it
+   * dead-lettered. Behind `wicked-crew governance replay`.
+   */
+  static replayEmitOutbox(outboxPath: string, dbPath: string): Promise<string>
   /**
    * Subscribe to the live [`CoreEvent`] stream. `callback` follows the Node error-first
    * convention — `(err, eventJson)` — and is invoked once per event with the event serialized as
@@ -119,21 +139,33 @@ export declare class Core {
   /** 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). 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.
+   * 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): Promise<string>
+  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}]`, sorted by id.
+   * `[{chatId, seats, idleSecs, cwd, codeGraphDb, readRoots}]`, 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).
    *
    * 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
@@ -240,8 +272,15 @@ export declare class Core {
   unitTranscript(unitId: string): 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 a capture-time `ts` (epoch millis)
-   * and an ordering `seq`.
+   * object the `/ws` stream carries ([`CoreEvent::to_json`]) plus the durable log's envelope — a
+   * capture-time `ts` (epoch millis) and an ordering `seq`; `RecordedEventJson` is the shape.
+   *
+   * Ordering contract (wicked-core#408): `seq` is strictly increasing within a run for the run's
+   * whole life, ACROSS daemon restarts — the engine continues a run's `seq` from its persisted
+   * log rather than from 0 — so the array is in emission order and its last entry is the run's
+   * latest event. The first entry a restarted engine records for a run carries
+   * `daemonRestarted: true` (absent everywhere else). `ts` may repeat within a burst; never order
+   * by it.
    *
    * The read half of FINDING-014: an evidence bundle assembled after a run must read what actually
    * happened rather than re-derive pseudo-events from unit records, which cannot recover what it
@@ -526,9 +565,10 @@ export declare class Core {
    * `core.db`), which holds run/governance nodes but none of a repo's domain/requirement nodes, so
    * it reports a vacuous `coverage: 1.0` over an empty denominator and cannot name a repo. This
    * resolves the repo from the registry, opens its `code_graph_db` (the engine-resolved path
-   * every consumer shares — the legacy in-tree `<root>/.codegraph/estate.db` for a repo that
-   * already has one, else the estate home's `<estate_root>/<key>/estate.db`; see wicked-core's
-   * `code_graph.rs` ADR), and recomputes over it. An unknown `repo_ref` is an
+   * every consumer shares — `<daemon state home>/repo-graphs/<key>/estate.db`, never inside the
+   * checkout; see wicked-core's `code_graph.rs` ADR, core#406), and recomputes over it. The
+   * daemon's own store path is handed along so the repo graph resolves under THIS daemon's
+   * state home off the actor thread. An unknown `repo_ref` is an
    * ERROR, never a silent vacuous report — the caller must name a real repo.
    * Resolves to the coverage report as a JSON string (`ts_return_type` pins it — the crew adapter
    * used to cast away an `unknown` here; #225 review).
@@ -655,4 +695,26 @@ export interface UnitDistributedEventJson extends CoreEventJson {
    */
   seatConstraint: string | null
 }
+
+/**
+ * One entry of the JSON array {@link Core.runEvents} resolves: the `/ws` frame ({@link CoreEventJson})
+ * plus the durable log's envelope. Ordering contract (wicked-core#408): `seq` is strictly increasing
+ * within a run for the run's WHOLE life — across daemon restarts, not just within one process — so
+ * the array is in emission order and its last entry is the run's latest event. `ts` is capture time
+ * (epoch millis) and may repeat within a burst; never order by it. The first entry a restarted
+ * engine records for a run carries `daemonRestarted: true` (absent everywhere else), marking the
+ * boundary for consumers that keep per-run state across the gap. All three are envelope-only: the
+ * live `/ws` frame carries none of them.
+ */
+export interface RecordedEventJson extends CoreEventJson {
+  /** Capture-time epoch millis. May repeat within a burst — not an order. */
+  ts: number
+  /**
+   * Strictly increasing within the run, across daemon restarts. NOT the per-terminal `seq` of
+   * `terminalOutput` frames — those are streaming chunks and are never recorded.
+   */
+  seq: number
+  /** Present, and `true`, only on the first entry a restarted engine recorded for this run. */
+  daemonRestarted?: true
+}
 // ─── end hand-authored ───

package/package.json

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