instar 1.3.520 → 1.3.522

package/dist/core/ReplicatedRecordEnvelope.js

@@ -0,0 +1,464 @@
+/**
+ * ReplicatedRecordEnvelope — the GENERIC substrate for replicated-store journal
+ * kinds (WS2 replicated-store foundation, Component 2 / Build-order step 2).
+ *
+ * Spec: docs/specs/multi-machine-replicated-store-foundation.md §4 (the
+ * replicated-record envelope, flag-gated + flag-coherence-gated emission), §10
+ * (config / advert / awareness), §13 build-order item 2, §14 (safety posture).
+ *
+ * This module is the REUSABLE machinery the concrete stores (WS2.1 preferences,
+ * relationships, learnings, …) layer a kind onto. It adds NO concrete store
+ * kind itself — the registry ships EMPTY. It provides exactly four pieces:
+ *
+ *   A. The replicated-record envelope type + a parameterizable STRICT validator
+ *      (`validateReplicatedEnvelope`) that mirrors the CoherenceJournal typed-
+ *      schema discipline: reject free text, drop unknown fields (counted), jail
+ *      any path-shaped field, validate `hlc` + (when present) `observed` as
+ *      well-formed HlcTimestamps. ABSENT `observed` is LEGAL ⇒ "no prior
+ *      witness" ⇒ flag-on-conflict (the safe direction, §4 / §7.2). The validated
+ *      envelope fields are AUTHORITATIVE: a store schema can never override a
+ *      reserved envelope field on the reconstructed `data` (reserved keys the
+ *      store returns are stripped + counted), and the path-jail is REUSABLE
+ *      machinery for store fields too — a store declares `pathSensitiveFields`
+ *      for auto-jailing, or calls the exported `jailStoreStringField` helper.
+ *      Reserved-key collisions in a store's `knownFields` are rejected at
+ *      registration time (a wiring-time programmer error), not trusted to a
+ *      store's self-check.
+ *
+ *   B. A registry of replicated kinds (`ReplicatedKindRegistry`) — the generic
+ *      registration mechanism a concrete store calls to register its kind +
+ *      store-specific field schema. Initially empty (no concrete kind).
+ *
+ *   C. Flag-gated emission (`isStoreEmissionEnabled`) — a replicated kind is
+ *      emitted ONLY when `multiMachine.stateSync.<store>.enabled` is true
+ *      (default FALSE). When off, strict no-op.
+ *
+ *   D. Flag-coherence-gated emission (`shouldEmitToPeer`,
+ *      `checkPoolFlagCoherence`) — a replicated kind is exchanged with a peer ONLY
+ *      when that peer's `seamlessnessFlags` advertises the matching
+ *      `stateSync.<store>` capability. The applier "silently drops unknown
+ *      kinds" (forward-compat). The per-peer decision is correct for N peers
+ *      (never assumes exactly 2); the boot-time pool-flag-coherence check
+ *      coalesces ALL mixed-flag peers into ONE surfaced result.
+ *
+ * TRANSPORT IS PULL — `shouldEmitToPeer` is intentionally UNWIRED in Step 2.
+ * The real journal-sync transport is RECEIVER-DRIVEN PULL: `PeerPresencePuller`
+ * iterates the SENDER's advert (`CoherenceJournal.getOwnAdvert()`, over the static
+ * `JOURNAL_KINDS` const) and pulls each kind it is behind on; serve + apply both
+ * gate on `JOURNAL_KINDS`. There is NO push-forward step. The named "emit a new
+ * kind to an OLD peer → silently dropped" mode therefore manifests as "an old
+ * peer NEVER PULLS a kind absent from its own JOURNAL_KINDS" (nothing requested ⇒
+ * nothing dropped). On this PULL transport the flag-coherence gate's role is the
+ * boot-time pool surface (`checkPoolFlagCoherence`, wired in server.ts) PLUS the
+ * serve/pull-decision gate the WS2.1 consumer PR will consult once a concrete
+ * kind exists — that is where `shouldEmitToPeer` will be called. In Step 2 it is
+ * a pure decision with no concrete kind to serve, hence intentionally unwired
+ * (NOT an unintegrated push gate).
+ *
+ * DUAL-REGISTRY COUPLING — a replicated kind MUST be added to BOTH registries.
+ * The new `ReplicatedKindRegistry` (read by the gate + the stateSyncReceive
+ * advert) and the static `JOURNAL_KINDS` (in CoherenceJournal.ts, gating serve +
+ * apply + enumerated by getOwnAdvert) are TWO parallel kind registries. A WS2.1
+ * PR that registers into `ReplicatedKindRegistry` but forgets `JOURNAL_KINDS`
+ * yields a store that advertises receive=true yet serves/applies/pulls nothing —
+ * a SILENT no-replication. The wiring-integrity test asserts every replicated
+ * kind is present in BOTH (a CI ratchet, not a memory item).
+ *
+ * SAFETY POSTURE (§14): this is MECHANISM, dark by default. NO gate here blocks
+ * a user-initiated action. The only refusals are at the RECEIVE door (the
+ * validator rejects malformed data) and the EMISSION door (don't forward a kind
+ * to a non-advertising peer). Both protect data; neither blocks the user. A
+ * single-machine install (no advertising peers) is a strict no-op — emission is
+ * gated on having a peer advertising the matching flag.
+ *
+ * Purity: this module imports ONLY the HLC primitive + node:path (for the
+ * path-shape jail's separator detection). No fs, no network, no Date. Every
+ * function is a pure function of its inputs.
+ */
+import path from 'node:path';
+import { coerceHlc } from './HybridLogicalClock.js';
+/** The envelope's own field names — the union of all reserved keys a store may
+ *  not reuse for a store-specific field. Exported AND ENFORCED:
+ *  ReplicatedKindRegistry.register() throws if a schema's `knownFields` claims any
+ *  of these, and validateReplicatedEnvelope strips any reserved key a store's
+ *  validate() returns (counting it as a dropped field) so the validated envelope
+ *  fields are the sole authority for the reconstructed `data`. */
+export const RESERVED_ENVELOPE_FIELDS = Object.freeze([
+    'recordKey',
+    'hlc',
+    'op',
+    'origin',
+    'observed',
+]);
+/** Caps (mirror the CoherenceJournal length-cap discipline — a value over the
+ *  cap is rejected, never truncated-and-accepted, so a record is whole or not). */
+export const MAX_RECORD_KEY_LENGTH = 512;
+export const MAX_ORIGIN_LENGTH = 256;
+/**
+ * Reusable store-field path-jail (the §4 "jail any path-shaped field" rule, made
+ * reusable machinery instead of per-store re-implementation). Returns the value
+ * unchanged when it is a NON-path-shaped string; returns null (and bumps the
+ * shared jail counter) when it is path-shaped, so a store's validate() can reject
+ * the whole record. A non-string is returned unchanged (the store does its own
+ * type check) — this helper enforces the PATH discipline only.
+ *
+ * Usage inside a store's validate():
+ *   const fp = jailStoreStringField(raw.filePath, ctx);
+ *   if (fp === null) return null; // path-shaped → reject whole record
+ */
+export function jailStoreStringField(value, ctx) {
+    if (typeof value === 'string' && isPathShaped(value)) {
+        ctx.countJailReject();
+        return null;
+    }
+    return value;
+}
+/**
+ * Is a string PATH-SHAPED? (The §4 "jail any path-shaped field" rule, applied
+ * to the envelope's string fields — recordKey/origin — so a path can never
+ * smuggle in as a primary key.) A value is path-shaped if it contains a path
+ * separator, a `..` traversal segment, or is an absolute path. This is a
+ * STRUCTURAL reject (the field has no business holding a path), not a
+ * filesystem jail — the envelope carries identifiers, never artifact paths.
+ */
+export function isPathShaped(value) {
+    if (path.isAbsolute(value))
+        return true;
+    if (value.includes('/') || value.includes('\\'))
+        return true;
+    // A bare `..` or any `..`-as-segment.
+    const segments = value.split(/[/\\]/);
+    if (segments.some((s) => s === '..' || s === '.'))
+        return true;
+    return false;
+}
+/** Validate one HLC field, returning the narrowed value or null (never throws). */
+function tryCoerceHlc(raw) {
+    try {
+        return coerceHlc(raw);
+    }
+    catch {
+        // @silent-fallback-ok: coerceHlc throws on malformed input by contract; here
+        // we are deliberately converting that into a typed rejection (null) so the
+        // validator can bump a counter and reject the WHOLE record — a malformed hlc
+        // is a schema reject, never a silent default. The reject is counted + surfaced
+        // by the caller via EnvelopeValidationCounters; nothing is swallowed.
+        return null;
+    }
+}
+/**
+ * The strict envelope validator (§4). Mirrors the CoherenceJournal typed-schema
+ * discipline:
+ *   - rejects a non-object,
+ *   - validates recordKey (non-empty, length-capped, NOT path-shaped → jail),
+ *   - validates hlc as a well-formed HlcTimestamp,
+ *   - validates op ∈ {'put','delete'},
+ *   - validates origin (non-empty, length-capped, NOT path-shaped),
+ *   - validates observed when present (well-formed HlcTimestamp); ABSENT is LEGAL,
+ *   - delegates store-specific fields to the supplied StoreFieldSchema,
+ *   - DROPS every field not in (RESERVED_ENVELOPE_FIELDS ∪ schema.knownFields),
+ *     counting each drop.
+ *
+ * Returns a typed result. NEVER throws on bad DATA — it bumps a counter and
+ * returns `{ ok: false }`. The reconstructed `data` object on success is the
+ * validated store fields + the validated envelope fields, in a deterministic
+ * shape (only known fields, observed omitted when absent), ready to serialize as
+ * the journal entry's `data`. The validated envelope fields are AUTHORITATIVE:
+ * any RESERVED_ENVELOPE_FIELDS key the store's validate() returns is stripped
+ * (and counted as a dropped field) before merge, so a store can NEVER override a
+ * load-bearing envelope field (op/recordKey/hlc/origin/observed) on `data` — the
+ * on-disk `data.op/recordKey/hlc/origin/observed` always equal the validated
+ * `envelope.*`. `storeFields` on the result is likewise reserved-key-stripped.
+ */
+export function validateReplicatedEnvelope(raw, schema, counters) {
+    if (!raw || typeof raw !== 'object' || Array.isArray(raw)) {
+        counters.bumpSchemaReject();
+        return { ok: false, reason: 'not-an-object' };
+    }
+    const obj = raw;
+    // recordKey — non-empty, length-capped, not path-shaped (jailed).
+    const recordKey = obj.recordKey;
+    if (typeof recordKey !== 'string' || recordKey.length === 0 || recordKey.length > MAX_RECORD_KEY_LENGTH) {
+        counters.bumpSchemaReject();
+        return { ok: false, reason: 'bad-record-key' };
+    }
+    if (isPathShaped(recordKey)) {
+        counters.bumpJailReject();
+        counters.bumpSchemaReject();
+        return { ok: false, reason: 'record-key-path-shaped' };
+    }
+    // hlc — well-formed HlcTimestamp (required).
+    const hlc = tryCoerceHlc(obj.hlc);
+    if (hlc === null) {
+        counters.bumpSchemaReject();
+        return { ok: false, reason: 'bad-hlc' };
+    }
+    // op — enum.
+    const op = obj.op;
+    if (op !== 'put' && op !== 'delete') {
+        counters.bumpSchemaReject();
+        return { ok: false, reason: 'bad-op' };
+    }
+    // origin — non-empty, length-capped, not path-shaped.
+    const origin = obj.origin;
+    if (typeof origin !== 'string' || origin.length === 0 || origin.length > MAX_ORIGIN_LENGTH) {
+        counters.bumpSchemaReject();
+        return { ok: false, reason: 'bad-origin' };
+    }
+    if (isPathShaped(origin)) {
+        counters.bumpJailReject();
+        counters.bumpSchemaReject();
+        return { ok: false, reason: 'bad-origin' };
+    }
+    // observed — well-formed HlcTimestamp WHEN PRESENT; absent is legal.
+    let observed;
+    if (obj.observed !== undefined && obj.observed !== null) {
+        const witness = tryCoerceHlc(obj.observed);
+        if (witness === null) {
+            counters.bumpSchemaReject();
+            return { ok: false, reason: 'bad-observed' };
+        }
+        observed = witness;
+    }
+    // Auto-jail every DECLARED path-sensitive store field BEFORE the store's own
+    // validate() — the §4 path-jail discipline applied to store fields as reusable
+    // machinery (Structure > Willpower), not left to each store to re-implement.
+    // A path-shaped declared field rejects the whole record (jail counter bumped),
+    // exactly as recordKey/origin do.
+    if (schema.pathSensitiveFields) {
+        for (const field of schema.pathSensitiveFields) {
+            const v = obj[field];
+            if (typeof v === 'string' && isPathShaped(v)) {
+                counters.bumpJailReject();
+                counters.bumpSchemaReject();
+                return { ok: false, reason: 'store-field-path-shaped' };
+            }
+        }
+    }
+    // Store-specific fields. The store validator may reject the whole record. The
+    // context carries BOTH counters so a store-side drop (countDroppedField) and a
+    // store-side imperative jail (countJailReject, e.g. via jailStoreStringField)
+    // feed the SAME counters CoherenceJournal surfaces — uniform accounting.
+    let storeRejected = false;
+    const storeCtx = {
+        countDroppedField: () => counters.bumpDroppedField(),
+        countJailReject: () => counters.bumpJailReject(),
+    };
+    const storeFields = schema.validate(obj, storeCtx);
+    if (storeFields === null) {
+        storeRejected = true;
+    }
+    if (storeRejected || storeFields === null) {
+        counters.bumpSchemaReject();
+        return { ok: false, reason: 'store-schema-rejected' };
+    }
+    // Count dropped unknown fields across the WHOLE object: any key not in the
+    // reserved envelope fields and not owned by the store schema is dropped.
+    const known = new Set([...RESERVED_ENVELOPE_FIELDS, ...schema.knownFields]);
+    for (const k of Object.keys(obj)) {
+        if (!known.has(k))
+            counters.bumpDroppedField();
+    }
+    const envelope = {
+        recordKey,
+        hlc,
+        op,
+        origin,
+        ...(observed !== undefined ? { observed } : {}),
+    };
+    // Defense-in-depth: a store schema's validate() returns the store-specific
+    // portion, but a buggy/hostile store COULD echo a RESERVED envelope key (op,
+    // recordKey, hlc, origin, observed) in its returned object. Those keys are
+    // load-bearing — op decides put/delete tombstone semantics, hlc is the merge
+    // total-order, recordKey is the primary key — and the store's copy is the
+    // UN-validated, UN-jailed value. We therefore STRIP every reserved key from
+    // the store's returned fields (counting each as a dropped field, the same as
+    // an unknown field) BEFORE merging, so the VALIDATED envelope fields are the
+    // sole authority for the reconstructed `data`. This makes the reserved keys
+    // un-overridable by construction — not "spread the envelope last and hope".
+    const reserved = new Set(RESERVED_ENVELOPE_FIELDS);
+    const storeFieldsSafe = {};
+    for (const [k, v] of Object.entries(storeFields)) {
+        if (reserved.has(k)) {
+            counters.bumpDroppedField();
+            continue;
+        }
+        storeFieldsSafe[k] = v;
+    }
+    // The reconstructed data shape: validated store fields (reserved keys stripped)
+    // FIRST, then the validated envelope fields LAST so a store can never clobber a
+    // load-bearing envelope field on a key collision. observed omitted when absent
+    // so the on-disk shape is deterministic.
+    const data = {
+        ...storeFieldsSafe,
+        recordKey,
+        hlc,
+        op,
+        origin,
+        ...(observed !== undefined ? { observed } : {}),
+    };
+    return { ok: true, envelope, storeFields: storeFieldsSafe, data };
+}
+/**
+ * A registry of replicated kinds. Ships EMPTY — Step 2 adds the GENERIC
+ * registration mechanism; the first concrete kind is registered by WS2.1.
+ *
+ * Why a registry (not a hardcoded union extension): the spec mandates "add the
+ * GENERIC registration mechanism" and "do NOT hardcode the future concrete
+ * kinds into the union in a way that forces them to exist now". A registry lets
+ * each store register independently at wiring time; an unregistered/never-
+ * emitted kind is simply absent on read (the reader filters by kind), and the
+ * applier already drops unknown kinds forward-compat — so an old peer that does
+ * not know a kind poisons nothing.
+ */
+export class ReplicatedKindRegistry {
+    byKind = new Map();
+    byStore = new Map();
+    /**
+     * Register a replicated kind. Idempotent for an IDENTICAL re-registration of
+     * the same (kind, store); THROWS on a CONFLICTING registration (a different
+     * store claiming an already-claimed kind, or a store re-registered with a
+     * different kind) — a registration conflict is a programmer error at wiring
+     * time, surfaced loudly, never a silent overwrite.
+     */
+    register(reg) {
+        if (typeof reg.kind !== 'string' || reg.kind.length === 0) {
+            throw new Error('ReplicatedKindRegistry.register: kind must be a non-empty string');
+        }
+        if (typeof reg.store !== 'string' || reg.store.length === 0) {
+            throw new Error('ReplicatedKindRegistry.register: store must be a non-empty string');
+        }
+        if (!reg.schema || typeof reg.schema.validate !== 'function' || !Array.isArray(reg.schema.knownFields)) {
+            throw new Error(`ReplicatedKindRegistry.register: kind "${reg.kind}" needs a StoreFieldSchema with knownFields[] + validate()`);
+        }
+        // ENFORCE non-collision with the reserved envelope fields (not merely
+        // documented for the store author to self-check). A schema that claims a
+        // reserved key in knownFields would defeat the unknown-field counter for that
+        // key (it'd be treated as store-owned), letting a store quietly opt a
+        // load-bearing envelope field into its own control surface. This is a
+        // wiring-time programmer error, surfaced loudly — same class as the conflict
+        // throws below, never a silent acceptance.
+        const reservedSet = new Set(RESERVED_ENVELOPE_FIELDS);
+        const claimedReserved = reg.schema.knownFields.filter((f) => reservedSet.has(f));
+        if (claimedReserved.length > 0) {
+            throw new Error(`ReplicatedKindRegistry.register: kind "${reg.kind}" schema.knownFields claims reserved envelope field(s) [${claimedReserved.join(',')}] — reserved fields are owned by the envelope and may not be store-owned`);
+        }
+        const existingByKind = this.byKind.get(reg.kind);
+        if (existingByKind) {
+            if (existingByKind.store !== reg.store) {
+                throw new Error(`ReplicatedKindRegistry: kind "${reg.kind}" already registered for store "${existingByKind.store}", cannot reassign to "${reg.store}"`);
+            }
+            // Same (kind, store) — idempotent; keep the first registration's schema.
+            return;
+        }
+        const existingByStore = this.byStore.get(reg.store);
+        if (existingByStore && existingByStore.kind !== reg.kind) {
+            throw new Error(`ReplicatedKindRegistry: store "${reg.store}" already owns kind "${existingByStore.kind}", cannot also claim "${reg.kind}"`);
+        }
+        this.byKind.set(reg.kind, reg);
+        this.byStore.set(reg.store, reg);
+    }
+    /** Is this kind a registered replicated kind? */
+    isReplicatedKind(kind) {
+        return this.byKind.has(kind);
+    }
+    /** The registration for a kind, or undefined if unregistered. */
+    getByKind(kind) {
+        return this.byKind.get(kind);
+    }
+    /** The registration for a store, or undefined if unregistered. */
+    getByStore(store) {
+        return this.byStore.get(store);
+    }
+    /** All registered kinds (the JournalKind strings). Empty until a store registers. */
+    kinds() {
+        return [...this.byKind.keys()];
+    }
+    /** All registered store keys. Empty until a store registers. */
+    stores() {
+        return [...this.byStore.keys()];
+    }
+    /** Count of registered kinds (0 in the Step-2 substrate-only state). */
+    get size() {
+        return this.byKind.size;
+    }
+}
+/**
+ * Is emission ENABLED for a store? (§4 flag-gated emission.) True ONLY when
+ * `stateSync[store].enabled === true` (default false). When off, the store
+ * NEVER emits its kind — a strict no-op. Nullish/absent ⇒ false.
+ */
+export function isStoreEmissionEnabled(stores, store) {
+    return stores?.[store]?.enabled === true;
+}
+/** Does THIS peer advertise the matching stateSync.<store> receive capability? */
+export function peerAdvertisesStore(peer, store) {
+    return peer.stateSyncReceive?.[store] === true;
+}
+/**
+ * The per-peer emission decision (§4 flag-coherence gating). Emit a replicated
+ * kind to a peer ONLY when:
+ *   - emission is enabled for the store locally (isStoreEmissionEnabled), AND
+ *   - the peer is online, AND
+ *   - the peer advertises the matching stateSync.<store> capability.
+ * Withhold otherwise — emitting to a non-advertising peer is the NAMED data-loss
+ * skew mode (the applier silently drops the unknown kind). Returns a typed
+ * decision so the caller can surface a withhold.
+ *
+ * This is PER-PEER and correct for N peers — the caller iterates peers and calls
+ * this once each; there is no "exactly 2" assumption anywhere.
+ */
+export function shouldEmitToPeer(stores, store, peer) {
+    if (!isStoreEmissionEnabled(stores, store))
+        return { emit: false, reason: 'store-disabled' };
+    if (peer.online === false)
+        return { emit: false, reason: 'peer-offline' };
+    if (!peerAdvertisesStore(peer, store))
+        return { emit: false, reason: 'peer-not-advertising' };
+    return { emit: true, reason: 'emit' };
+}
+/**
+ * The boot-time pool-flag-coherence check (§4: "A boot-time pool-flag-coherence
+ * check surfaces (ONCE) any mixed state"). Iterates ALL registered replicated
+ * stores × ALL advertising peers and computes, per store, the advertising vs
+ * non-advertising online peers. A store is MIXED when it is locally enabled AND
+ * has at least one online peer that does NOT advertise it (that peer would
+ * silently drop our kind) alongside at least one online peer that DOES (or there
+ * is anyone at all to forward to). The result is ONE coalesced object — the
+ * caller surfaces it once (e.g. one Attention item / one log line), never one
+ * per peer per tick. Correct for N peers.
+ *
+ * PURE: no I/O, no surfacing — it computes the verdict; the caller decides how
+ * to surface (and dedupes across boots).
+ */
+export function checkPoolFlagCoherence(registry, stores, peers) {
+    const onlinePeers = peers.filter((p) => p.online !== false);
+    const out = [];
+    const mixedStores = [];
+    const summary = [];
+    for (const store of registry.stores()) {
+        // Only locally-enabled stores can emit, so only they can suffer the skew.
+        if (!isStoreEmissionEnabled(stores, store))
+            continue;
+        const advertising = [];
+        const notAdvertising = [];
+        for (const peer of onlinePeers) {
+            if (peerAdvertisesStore(peer, store))
+                advertising.push(peer.machineId);
+            else
+                notAdvertising.push(peer.machineId);
+        }
+        // MIXED = locally enabled (we will emit) AND ≥1 online peer cannot receive
+        // it. That non-advertiser is the silent-drop victim — the named skew mode.
+        const mixed = notAdvertising.length > 0;
+        out.push({ store, advertising, notAdvertising, mixed });
+        if (mixed) {
+            mixedStores.push(store);
+            // Content-free: store key + counts + the non-advertiser ids (machine ids
+            // are routing identifiers, not user content).
+            summary.push(`stateSync.${store}: ${advertising.length} peer(s) ready, ${notAdvertising.length} peer(s) cannot receive (would silently drop) [${notAdvertising.join(',')}]`);
+        }
+    }
+    return { stores: out, mixedStores, summary };
+}
+//# sourceMappingURL=ReplicatedRecordEnvelope.js.map

package/dist/core/ReplicatedRecordEnvelope.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ReplicatedRecordEnvelope.js","sourceRoot":"","sources":["../../src/core/ReplicatedRecordEnvelope.ts"],"names":[],"mappings":"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"}

package/dist/core/devGatedFeatures.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"devGatedFeatures.d.ts","sourceRoot":"","sources":["../../src/core/devGatedFeatures.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AAEH,oEAAoE;AACpE,MAAM,WAAW,eAAe;IAC9B,mEAAmE;IACnE,IAAI,EAAE,MAAM,CAAC;IACb,uEAAuE;IACvE,UAAU,EAAE,MAAM,CAAC;IACnB,6DAA6D;IAC7D,WAAW,EAAE,MAAM,CAAC;IACpB;;;;;;OAMG;IACH,aAAa,EAAE,MAAM,CAAC;CACvB;AAED,eAAO,MAAM,kBAAkB,EAAE,eAAe,EAiG/C,CAAC;AAEF;;;;;;;;;;;;GAYG;AACH,MAAM,MAAM,gBAAgB,GACxB,aAAa,GACb,sBAAsB,GACtB,cAAc,GACd,iBAAiB,GACjB,0BAA0B,CAAC;AAE/B,MAAM,WAAW,iBAAiB;IAChC,uEAAuE;IACvE,UAAU,EAAE,MAAM,CAAC;IACnB,6CAA6C;IAC7C,QAAQ,EAAE,gBAAgB,CAAC;IAC3B,mFAAmF;IACnF,MAAM,EAAE,MAAM,CAAC;CAChB;AAED,eAAO,MAAM,oBAAoB,EAAE,iBAAiB,EAyHnD,CAAC;AAEF;;;GAGG;AACH,wBAAgB,eAAe,CAAC,MAAM,EAAE,OAAO,EAAE,UAAU,EAAE,MAAM,GAAG,OAAO,CAO5E"}
+{"version":3,"file":"devGatedFeatures.d.ts","sourceRoot":"","sources":["../../src/core/devGatedFeatures.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AAEH,oEAAoE;AACpE,MAAM,WAAW,eAAe;IAC9B,mEAAmE;IACnE,IAAI,EAAE,MAAM,CAAC;IACb,uEAAuE;IACvE,UAAU,EAAE,MAAM,CAAC;IACnB,6DAA6D;IAC7D,WAAW,EAAE,MAAM,CAAC;IACpB;;;;;;OAMG;IACH,aAAa,EAAE,MAAM,CAAC;CACvB;AAED,eAAO,MAAM,kBAAkB,EAAE,eAAe,EAyG/C,CAAC;AAEF;;;;;;;;;;;;GAYG;AACH,MAAM,MAAM,gBAAgB,GACxB,aAAa,GACb,sBAAsB,GACtB,cAAc,GACd,iBAAiB,GACjB,0BAA0B,CAAC;AAE/B,MAAM,WAAW,iBAAiB;IAChC,uEAAuE;IACvE,UAAU,EAAE,MAAM,CAAC;IACnB,6CAA6C;IAC7C,QAAQ,EAAE,gBAAgB,CAAC;IAC3B,mFAAmF;IACnF,MAAM,EAAE,MAAM,CAAC;CAChB;AAED,eAAO,MAAM,oBAAoB,EAAE,iBAAiB,EAyHnD,CAAC;AAEF;;;GAGG;AACH,wBAAgB,eAAe,CAAC,MAAM,EAAE,OAAO,EAAE,UAAU,EAAE,MAAM,GAAG,OAAO,CAO5E"}

package/dist/core/devGatedFeatures.js

@@ -114,6 +114,12 @@ export const DEV_GATED_FEATURES = [
         description: 'Threadline single-negotiator lease — one session owns each conversation\'s outbound voice (THREADLINE-SINGLE-NEGOTIATOR-SPEC, CMT-1362).',
         justification: 'Lives live on a dev agent ONLY in dry-run (dryRun defaults true) — it engages the lease logic and logs every would-hold verdict for the FD-7 false-positive telemetry but withholds NOTHING (a real send is only blocked by an explicit dryRun:false). No egress, no spend, no destructive action; this is exactly the dogfooding posture FD-7 requires before the lease can ever enforce. (Was mis-classified deliberate-fleet-default at ship, which starved the telemetry — corrected here.)',
     },
+    {
+        name: 'orphanedWorkSentinel',
+        configPath: 'monitoring.orphanedWorkSentinel.enabled',
+        description: 'Silent-uncommitted-death backstop — flags agent worktrees with uncommitted work whose owning session died (/orphaned-work).',
+        justification: 'Signal-only local recorder + ONE deduped attention item; reads git status/diff + lsof read-only; no egress, no spend, no destructive action. The optional preservation is a NON-destructive patch write (git diff → a state-dir file) behind an off-by-default preserveWork sub-flag — it never mutates the worktree, its index, or any ref.',
+    },
 ];
 export const DARK_GATE_EXCLUSIONS = [
     // ── destructive — kills/deletes on a heuristic; off + dry-run for EVERYONE ──

package/dist/core/devGatedFeatures.js.map

@@ -1 +1 @@
-{"version":3,"file":"devGatedFeatures.js","sourceRoot":"","sources":["../../src/core/devGatedFeatures.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"devGatedFeatures.js","sourceRoot":"","sources":["../../src/core/devGatedFeatures.ts"],"names":[],"mappings":"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"}

package/dist/core/stateSyncConfig.d.ts

@@ -0,0 +1,94 @@
+/**
+ * stateSync config resolution + invariant validation (WS2 replicated-store
+ * foundation, §10.2).
+ *
+ * Spec: docs/specs/multi-machine-replicated-store-foundation.md §10 (config
+ * schema, validateStateSyncInvariants, rollout posture), §3.4 (the maxDriftMs
+ * clamp), §8.2 (snapshot-cache ceilings).
+ *
+ * Mirrors `seamlessnessConfig.ts`: resolve the optional `multiMachine.stateSync`
+ * knobs to concrete values, then enforce the cross-knob invariants. A violating
+ * config is REJECTED with a clear message (StateSyncConfigError) rather than
+ * silently coerced — the §10.2 contract: "a bad config is REJECTED, not silently
+ * degraded". The per-store `enabled` flags are NOT validated here (they are the
+ * dark-by-default on-switches, store by store); this module governs the
+ * FOUNDATION-LEVEL knobs every store shares (the journal budget, the HLC drift
+ * ceiling, the snapshot cache bounds).
+ */
+import { DEFAULT_MAX_DRIFT_MS, MIN_MAX_DRIFT_MS, MAX_MAX_DRIFT_MS } from './HybridLogicalClock.js';
+import type { MultiMachineConfig } from './types.js';
+/** Foundation-level stateSync defaults (§10.2). */
+export declare const DEFAULT_AGGREGATE_JOURNAL_BUDGET_BYTES: number;
+export declare const DEFAULT_MAX_CACHED_SNAPSHOTS = 16;
+export declare const DEFAULT_MAX_CACHE_BYTES: number;
+/**
+ * The propagation allowance (§10.2): the invariant `maxDriftMs > flush interval +
+ * propagation allowance` must hold so the drift bound can never be tighter than
+ * the journal's own flush+replicate latency (which would quarantine our own
+ * in-flight writes). With the 60s floor this always holds; the allowance is the
+ * realistic worst-case mesh propagation lag we account for explicitly.
+ */
+export declare const DEFAULT_PROPAGATION_ALLOWANCE_MS: number;
+/** Fully-resolved foundation-level stateSync knobs (every field concrete). */
+export interface ResolvedStateSyncConfig {
+    /** Aggregate journal byte budget across all replicated kinds (§10.2). */
+    aggregateJournalBudgetBytes: number;
+    /** The CLAMPED HLC bounded-drift ceiling the clock enforces (§3.4 / §10.2). */
+    maxDriftMs: number;
+    /** Snapshot-cache count ceiling (§8.2). */
+    maxCachedSnapshots: number;
+    /** Snapshot-cache byte ceiling (§8.2). */
+    maxCacheBytes: number;
+}
+export declare class StateSyncConfigError extends Error {
+    constructor(message: string);
+}
+/** The minimal shape this module reads from config — the per-store flags are a
+ *  free-form map (a store's key → { enabled, dryRun }); the foundation knobs are
+ *  optional siblings. Mirrors the spec §10 schema. */
+export interface StateSyncRawConfig {
+    aggregateJournalBudgetBytes?: number;
+    maxDriftMs?: number;
+    maxCachedSnapshots?: number;
+    maxCacheBytes?: number;
+    /** Per-store on-switches live as sibling keys; this module ignores their
+     *  shape beyond the foundation knobs. Stores are typed loosely so a new
+     *  store added later needs no change here. */
+    [store: string]: unknown;
+}
+/** Read the stateSync block off a multiMachine config (may be absent). */
+export declare function readStateSyncRaw(mm?: MultiMachineConfig): StateSyncRawConfig | undefined;
+/**
+ * Resolve the foundation-level stateSync knobs to concrete values. Does NOT
+ * validate — call validateStateSyncInvariants() after (or use
+ * assertStateSyncInvariants() for resolve+validate+throw in one step). The
+ * maxDriftMs is CLAMPED here via the clock's clampMaxDriftMs so a resolved value
+ * is always in-range; the §10.2 invariant additionally REJECTS an out-of-range
+ * RAW value (so an operator sees an error, not a silent clamp) — see
+ * validateStateSyncInvariants.
+ */
+export declare function resolveStateSyncConfig(mm?: MultiMachineConfig): ResolvedStateSyncConfig;
+/**
+ * Validate the foundation-level stateSync invariants (§10.2). Returns the list
+ * of violations (empty = valid). Operates on the RAW config (not the resolved
+ * one) for the maxDriftMs range check, so an out-of-range value is REJECTED
+ * rather than silently clamped — the spec's "rejected, not silently coerced".
+ *
+ * Invariants (§10.2):
+ *  1. aggregateJournalBudgetBytes > 0.
+ *  2. maxDriftMs within [60_000, 900_000] (the §3.4 clamp) — out-of-range REJECTED.
+ *  3. maxDriftMs > flush interval + propagation allowance (NOT the vacuous
+ *     "> flush window") — so the bound can never be tighter than the journal's
+ *     own flush+replicate latency.
+ *  4. maxCachedSnapshots > 0 and maxCacheBytes > 0 (§8.2).
+ */
+export declare function validateStateSyncInvariants(mm?: MultiMachineConfig): string[];
+/**
+ * Resolve + validate in one step, throwing StateSyncConfigError on any invariant
+ * violation. Use at server startup so a bad config is rejected loudly rather
+ * than degrading silently (mirrors assertSeamlessnessInvariants).
+ */
+export declare function assertStateSyncInvariants(mm?: MultiMachineConfig): ResolvedStateSyncConfig;
+/** Re-export the drift-clamp constants for callers/tests that assert the range. */
+export { DEFAULT_MAX_DRIFT_MS, MIN_MAX_DRIFT_MS, MAX_MAX_DRIFT_MS };
+//# sourceMappingURL=stateSyncConfig.d.ts.map

package/dist/core/stateSyncConfig.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stateSyncConfig.d.ts","sourceRoot":"","sources":["../../src/core/stateSyncConfig.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAEH,OAAO,EAEL,oBAAoB,EACpB,gBAAgB,EAChB,gBAAgB,EACjB,MAAM,yBAAyB,CAAC;AAEjC,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,YAAY,CAAC;AAErD,mDAAmD;AACnD,eAAO,MAAM,sCAAsC,QAAmB,CAAC;AACvE,eAAO,MAAM,4BAA4B,KAAK,CAAC;AAC/C,eAAO,MAAM,uBAAuB,QAAmB,CAAC;AACxD;;;;;;GAMG;AACH,eAAO,MAAM,gCAAgC,QAAY,CAAC;AAE1D,8EAA8E;AAC9E,MAAM,WAAW,uBAAuB;IACtC,yEAAyE;IACzE,2BAA2B,EAAE,MAAM,CAAC;IACpC,+EAA+E;IAC/E,UAAU,EAAE,MAAM,CAAC;IACnB,2CAA2C;IAC3C,kBAAkB,EAAE,MAAM,CAAC;IAC3B,0CAA0C;IAC1C,aAAa,EAAE,MAAM,CAAC;CACvB;AAED,qBAAa,oBAAqB,SAAQ,KAAK;gBACjC,OAAO,EAAE,MAAM;CAI5B;AAED;;sDAEsD;AACtD,MAAM,WAAW,kBAAkB;IACjC,2BAA2B,CAAC,EAAE,MAAM,CAAC;IACrC,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,kBAAkB,CAAC,EAAE,MAAM,CAAC;IAC5B,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB;;kDAE8C;IAC9C,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC;CAC1B;AAED,0EAA0E;AAC1E,wBAAgB,gBAAgB,CAAC,EAAE,CAAC,EAAE,kBAAkB,GAAG,kBAAkB,GAAG,SAAS,CAGxF;AAED;;;;;;;;GAQG;AACH,wBAAgB,sBAAsB,CAAC,EAAE,CAAC,EAAE,kBAAkB,GAAG,uBAAuB,CAQvF;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,2BAA2B,CAAC,EAAE,CAAC,EAAE,kBAAkB,GAAG,MAAM,EAAE,CA2C7E;AAED;;;;GAIG;AACH,wBAAgB,yBAAyB,CAAC,EAAE,CAAC,EAAE,kBAAkB,GAAG,uBAAuB,CAS1F;AAED,mFAAmF;AACnF,OAAO,EAAE,oBAAoB,EAAE,gBAAgB,EAAE,gBAAgB,EAAE,CAAC"}