@adhd/sox-embedding-provider 0.4.1 → 0.5.1

package/dist/onnxStderrFilter.d.ts

@@ -0,0 +1,78 @@
+/**
+ * (BUG-EMBED-ONNX-COREML-STDERR-NOISE-001) Filters the ONNX Runtime CoreML
+ * graph-partitioning warning out of the fastembed child's inherited stderr,
+ * while forwarding every other byte through verbatim, unbuffered, and in
+ * order.
+ *
+ * ── Why this exists ─────────────────────────────────────────────────────────
+ *
+ * `sharedFastembedProcess.ts` forks `fastembedProcessHost.ts` with
+ * `resolveExecutionProviders()` returning `['coreml', 'cpu']` on darwin
+ * (`fastembedProcessHost.ts`). bge-base's `word_embeddings` tensor is shaped
+ * `{30522,768}`, and CoreML's execution provider cannot host any input
+ * dimension over 16384 — so onnxruntime's native CoreML EP logs, at EVERY
+ * model load:
+ *
+ *   [W:onnxruntime:, helper.cc:83 IsInputSupported] CoreML does not support
+ *   input dim > 16384. Input:embeddings.word_embeddings.weight,
+ *   shape: {30522,768}
+ *
+ * This is emitted by the native onnxruntime addon straight to the process's
+ * real stderr fd (not through any JS logger this package controls), and
+ * `sharedFastembedProcess.ts` forks the child with
+ * `stdio: ['ignore', 'inherit', 'inherit', 'ipc']` — so it lands on every
+ * `adhd-backlog` (or any other consumer) invocation's terminal, on every
+ * single command, even though the node in question simply falls back to CPU
+ * silently and nothing is actually wrong.
+ *
+ * ── Why this is a stderr *filter*, not a log-severity option ────────────────
+ *
+ * onnxruntime-node's `InferenceSession.SessionOptions` DOES expose a
+ * `logSeverityLevel` (0=Verbose…4=Fatal) that would suppress Warning-level
+ * messages at the source — a cleaner fix, if it were reachable. It is not:
+ * `fastembed@2.1.0`'s `FlagEmbedding.init()` (`fastembed.js`'s
+ * `ort.InferenceSession.create(modelPath, { executionProviders,
+ * graphOptimizationLevel: "all" })`) hardcodes its own `SessionOptions`
+ * literal with no passthrough for caller options, and `fastembed`'s public
+ * `InitOptions` type has no `sessionOptions`/`logSeverityLevel` field either
+ * (verified against the installed `fastembed@2.1.0` and
+ * `onnxruntime-node@1.21.0` packages — not assumed). Filtering the child's
+ * stderr byte stream is therefore the only lever this package can pull.
+ *
+ * ── Why this must NOT become "throw away all child stderr" ──────────────────
+ *
+ * `fastembedProcessHost.ts`'s BL-331 lock check intentionally
+ * `console.error`s a loud, greppable line when a competing fastembed host is
+ * detected (guarding against a silent 25-50x embed-latency regression), and
+ * `resolveExecutionProviders()` intentionally `console.error`s when
+ * `SOX_EMBED_EXECUTION_PROVIDER` forces a non-default provider. A blanket
+ * "pipe stderr, discard everything" fix would silently destroy both of those
+ * — reintroducing exactly the silent-failure class BL-331 exists to prevent.
+ * So this filter matches ONLY the known-benign CoreML dim-limit warning text
+ * and passes every other line — including genuine errors and both lines
+ * above — straight through unmodified.
+ */
+/**
+ * True if `line` is the known-benign ONNX Runtime CoreML dim-limit warning
+ * (see module doc comment). This is a plain substring match — deliberately
+ * narrow (not a broad `onnxruntime`/`[W:` pattern) so this filter can never
+ * swallow an unrelated onnxruntime warning or error that happens to share the
+ * `[W:onnxruntime:...]` prefix format.
+ */
+export declare function isBenignOnnxCoreMlWarning(line: string): boolean;
+/**
+ * Attach a line-buffering filter to a child process's stderr `Readable`,
+ * dropping only lines matching {@link isBenignOnnxCoreMlWarning} and writing
+ * every other line through to `dest` (defaults to `process.stderr`)
+ * unbuffered, verbatim (original line content, `\n`-terminated), and in the
+ * order it was received.
+ *
+ * Chunk boundaries never line up with `\n` boundaries in a real pipe, so
+ * this buffers a trailing partial line across `data` events instead of
+ * filtering mid-line: `source` is split on `\n` as chunks arrive, each
+ * complete line is tested and (if not benign) written immediately, and any
+ * remaining partial line is flushed on `end` (also filtered, so a benign
+ * warning that happens to be the final unterminated write is still caught).
+ */
+export declare function attachOnnxStderrFilter(source: NodeJS.ReadableStream, dest?: NodeJS.WritableStream): void;
+//# sourceMappingURL=onnxStderrFilter.d.ts.map

package/dist/onnxStderrFilter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"onnxStderrFilter.d.ts","sourceRoot":"","sources":["../src/onnxStderrFilter.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqDG;AAIH;;;;;;GAMG;AACH,wBAAgB,yBAAyB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAE/D;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,sBAAsB,CACpC,MAAM,EAAE,MAAM,CAAC,cAAc,EAC7B,IAAI,GAAE,MAAM,CAAC,cAA+B,GAC3C,IAAI,CAmBN"}

package/dist/onnxStderrFilter.js

@@ -0,0 +1,100 @@
+/**
+ * (BUG-EMBED-ONNX-COREML-STDERR-NOISE-001) Filters the ONNX Runtime CoreML
+ * graph-partitioning warning out of the fastembed child's inherited stderr,
+ * while forwarding every other byte through verbatim, unbuffered, and in
+ * order.
+ *
+ * ── Why this exists ─────────────────────────────────────────────────────────
+ *
+ * `sharedFastembedProcess.ts` forks `fastembedProcessHost.ts` with
+ * `resolveExecutionProviders()` returning `['coreml', 'cpu']` on darwin
+ * (`fastembedProcessHost.ts`). bge-base's `word_embeddings` tensor is shaped
+ * `{30522,768}`, and CoreML's execution provider cannot host any input
+ * dimension over 16384 — so onnxruntime's native CoreML EP logs, at EVERY
+ * model load:
+ *
+ *   [W:onnxruntime:, helper.cc:83 IsInputSupported] CoreML does not support
+ *   input dim > 16384. Input:embeddings.word_embeddings.weight,
+ *   shape: {30522,768}
+ *
+ * This is emitted by the native onnxruntime addon straight to the process's
+ * real stderr fd (not through any JS logger this package controls), and
+ * `sharedFastembedProcess.ts` forks the child with
+ * `stdio: ['ignore', 'inherit', 'inherit', 'ipc']` — so it lands on every
+ * `adhd-backlog` (or any other consumer) invocation's terminal, on every
+ * single command, even though the node in question simply falls back to CPU
+ * silently and nothing is actually wrong.
+ *
+ * ── Why this is a stderr *filter*, not a log-severity option ────────────────
+ *
+ * onnxruntime-node's `InferenceSession.SessionOptions` DOES expose a
+ * `logSeverityLevel` (0=Verbose…4=Fatal) that would suppress Warning-level
+ * messages at the source — a cleaner fix, if it were reachable. It is not:
+ * `fastembed@2.1.0`'s `FlagEmbedding.init()` (`fastembed.js`'s
+ * `ort.InferenceSession.create(modelPath, { executionProviders,
+ * graphOptimizationLevel: "all" })`) hardcodes its own `SessionOptions`
+ * literal with no passthrough for caller options, and `fastembed`'s public
+ * `InitOptions` type has no `sessionOptions`/`logSeverityLevel` field either
+ * (verified against the installed `fastembed@2.1.0` and
+ * `onnxruntime-node@1.21.0` packages — not assumed). Filtering the child's
+ * stderr byte stream is therefore the only lever this package can pull.
+ *
+ * ── Why this must NOT become "throw away all child stderr" ──────────────────
+ *
+ * `fastembedProcessHost.ts`'s BL-331 lock check intentionally
+ * `console.error`s a loud, greppable line when a competing fastembed host is
+ * detected (guarding against a silent 25-50x embed-latency regression), and
+ * `resolveExecutionProviders()` intentionally `console.error`s when
+ * `SOX_EMBED_EXECUTION_PROVIDER` forces a non-default provider. A blanket
+ * "pipe stderr, discard everything" fix would silently destroy both of those
+ * — reintroducing exactly the silent-failure class BL-331 exists to prevent.
+ * So this filter matches ONLY the known-benign CoreML dim-limit warning text
+ * and passes every other line — including genuine errors and both lines
+ * above — straight through unmodified.
+ */
+const BENIGN_CORE_ML_WARNING_SUBSTRING = 'CoreML does not support input dim > 16384';
+/**
+ * True if `line` is the known-benign ONNX Runtime CoreML dim-limit warning
+ * (see module doc comment). This is a plain substring match — deliberately
+ * narrow (not a broad `onnxruntime`/`[W:` pattern) so this filter can never
+ * swallow an unrelated onnxruntime warning or error that happens to share the
+ * `[W:onnxruntime:...]` prefix format.
+ */
+export function isBenignOnnxCoreMlWarning(line) {
+    return line.includes(BENIGN_CORE_ML_WARNING_SUBSTRING);
+}
+/**
+ * Attach a line-buffering filter to a child process's stderr `Readable`,
+ * dropping only lines matching {@link isBenignOnnxCoreMlWarning} and writing
+ * every other line through to `dest` (defaults to `process.stderr`)
+ * unbuffered, verbatim (original line content, `\n`-terminated), and in the
+ * order it was received.
+ *
+ * Chunk boundaries never line up with `\n` boundaries in a real pipe, so
+ * this buffers a trailing partial line across `data` events instead of
+ * filtering mid-line: `source` is split on `\n` as chunks arrive, each
+ * complete line is tested and (if not benign) written immediately, and any
+ * remaining partial line is flushed on `end` (also filtered, so a benign
+ * warning that happens to be the final unterminated write is still caught).
+ */
+export function attachOnnxStderrFilter(source, dest = process.stderr) {
+    let buffer = '';
+    source.on('data', (chunk) => {
+        buffer += chunk.toString('utf8');
+        let idx;
+        while ((idx = buffer.indexOf('\n')) !== -1) {
+            const line = buffer.slice(0, idx);
+            buffer = buffer.slice(idx + 1);
+            if (!isBenignOnnxCoreMlWarning(line)) {
+                dest.write(`${line}\n`);
+            }
+        }
+    });
+    source.on('end', () => {
+        if (buffer.length > 0 && !isBenignOnnxCoreMlWarning(buffer)) {
+            dest.write(buffer);
+        }
+        buffer = '';
+    });
+}
+//# sourceMappingURL=onnxStderrFilter.js.map

package/dist/onnxStderrFilter.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"onnxStderrFilter.js","sourceRoot":"","sources":["../src/onnxStderrFilter.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqDG;AAEH,MAAM,gCAAgC,GAAG,2CAA2C,CAAC;AAErF;;;;;;GAMG;AACH,MAAM,UAAU,yBAAyB,CAAC,IAAY;IACpD,OAAO,IAAI,CAAC,QAAQ,CAAC,gCAAgC,CAAC,CAAC;AACzD,CAAC;AAED;;;;;;;;;;;;;GAaG;AACH,MAAM,UAAU,sBAAsB,CACpC,MAA6B,EAC7B,OAA8B,OAAO,CAAC,MAAM;IAE5C,IAAI,MAAM,GAAG,EAAE,CAAC;IAChB,MAAM,CAAC,EAAE,CAAC,MAAM,EAAE,CAAC,KAAsB,EAAE,EAAE;QAC3C,MAAM,IAAI,KAAK,CAAC,QAAQ,CAAC,MAAM,CAAC,CAAC;QACjC,IAAI,GAAW,CAAC;QAChB,OAAO,CAAC,GAAG,GAAG,MAAM,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC;YAC3C,MAAM,IAAI,GAAG,MAAM,CAAC,KAAK,CAAC,CAAC,EAAE,GAAG,CAAC,CAAC;YAClC,MAAM,GAAG,MAAM,CAAC,KAAK,CAAC,GAAG,GAAG,CAAC,CAAC,CAAC;YAC/B,IAAI,CAAC,yBAAyB,CAAC,IAAI,CAAC,EAAE,CAAC;gBACrC,IAAI,CAAC,KAAK,CAAC,GAAG,IAAI,IAAI,CAAC,CAAC;YAC1B,CAAC;QACH,CAAC;IACH,CAAC,CAAC,CAAC;IACH,MAAM,CAAC,EAAE,CAAC,KAAK,EAAE,GAAG,EAAE;QACpB,IAAI,MAAM,CAAC,MAAM,GAAG,CAAC,IAAI,CAAC,yBAAyB,CAAC,MAAM,CAAC,EAAE,CAAC;YAC5D,IAAI,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC;QACrB,CAAC;QACD,MAAM,GAAG,EAAE,CAAC;IACd,CAAC,CAAC,CAAC;AACL,CAAC"}

package/dist/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adhd/sox-embedding-provider",
-  "version": "0.4.0",
+  "version": "0.5.0",
   "description": "Pluggable text→vector embedding provider — generic EmbeddingProvider interface, config-driven model resolution, async batch-first API (AsyncIterable). Default: fastembed (local ONNX, >=3 model dims proven). Loud-fail: createEmbeddingProvider() throws ResolutionError if config is invalid or model cannot load — no silent downgrade.",
   "license": "MIT",
   "private": false,

package/dist/sharedFastembedProcess.d.ts

@@ -28,10 +28,18 @@ export declare function __resetCompetingHostCacheForTests(): void;
  * `competing_host_pid` telemetry field would read as permanently "contended"
  * for every pooled request, which is exactly the false-positive noise BL-331's
  * own postmortem warns against trusting.
+ *
+ * (BL-432) `ownService`, when supplied, does the same for SERVICE identity: a
+ * lock entry whose `service` equals our own is the sequential-CLI false
+ * positive (our own service's earlier/second host), not cross-service
+ * contention, and is suppressed. Requires BOTH sides to carry a real identity —
+ * `ownService === undefined` or an unlabelled/old lock keeps the original
+ * behaviour. The returned `service` is `null` when the lock carries none.
  */
-export declare function detectCompetingFastembedHost(ownPid: number | undefined, ownPoolGroup?: string): {
+export declare function detectCompetingFastembedHost(ownPid: number | undefined, ownPoolGroup?: string, ownService?: string): {
     pid: number;
     startedAt: string;
+    service: string | null;
 } | null;
 /**
  * (BUG-MEMORY-EMBED-HEAD-OF-LINE-BLOCKING-001) The structural shape both
@@ -224,9 +232,12 @@ export declare class SharedFastembedProcessClient implements SharedFastembedClie
      *      `queue_depth` > 0 alongside a `response_ms` that scales with it) is
      *      distinguishable from "the child itself was slow on a solo request"
      *      (`queue_depth` === 0 with a large `response_ms`).
-     *   3. `competing_host_pid` — present only when a second, still-live
-     *      `fastembedProcessHost` process is detected (BL-331's advisory lock),
-     *      since that changes embed latency 25-50x independent of queueing.
+     *   3. `competing_host_pid` (+ `competing_host_service`, BL-432) — present
+     *      only when a second, still-live `fastembedProcessHost` process belonging
+     *      to a DIFFERENT service is detected (BL-331's advisory lock), since
+     *      that changes embed latency 25-50x independent of queueing. A
+     *      same-service lock (the sequential-CLI false positive) is suppressed,
+     *      so this field means genuine cross-service contention.
      *
      * BL-576: `signal`, when supplied, is an external cancellation source —
      * e.g. `operation-guard.ts`'s `withOperationDeadline` abort controller, so
@@ -541,4 +552,23 @@ export declare function getSharedFastembedProcess(): SharedFastembedClient;
  * needed.
  */
 export declare function __resetSharedFastembedProcessForTests(): void;
+/**
+ * (BUG-MEMORYSERVER-EMBED-HEAL-NOOPERATOR-001) Kill AND clear the shared
+ * fastembed host singleton, so the next `getSharedFastembedProcess()` forks a
+ * genuinely fresh child process (and re-inits the model). This is the
+ * embedding-provider half of memory-core's `reinitEmbedProvider()` — the
+ * self-heal path that recovers a wedged fastembed child (BUG-021's
+ * "Model not initialized" respawn-without-reinit state) by tearing the whole
+ * shared host down and re-forking from scratch, rather than waiting for the
+ * dead child to be reaped.
+ *
+ * Unlike `__resetSharedFastembedProcessForTests` (test-only, does NOT
+ * terminate), this TERMINATES the existing singleton first — killing the child
+ * process(es) via the normal `terminate()` shutdown sequence (BL-405's clean
+ * `__shutdown` message, `kill()` fallback) — and only then drops the singleton
+ * reference. Safe to call when no singleton has ever been constructed (no-op).
+ * Any in-flight request is rejected with the standard termination error, which
+ * the heal loop surfaces as a row failure — never a hang.
+ */
+export declare function resetSharedFastembedProcess(): Promise<void>;
 //# sourceMappingURL=sharedFastembedProcess.d.ts.map

package/dist/sharedFastembedProcess.d.ts.map

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

package/dist/sharedFastembedProcess.js

@@ -15,14 +15,15 @@
  * process alive) but forks a child **process** instead of constructing a
  * `worker_threads.Worker`.
  */
-import { fork, execSync } from 'node:child_process';
+import { execSync } from 'node:child_process';
 import { fileURLToPath } from 'node:url';
 import { dirname, join } from 'node:path';
 import { existsSync, readFileSync } from 'node:fs';
 import * as os from 'node:os';
 import { performance } from 'node:perf_hooks';
-import { log } from '@adhd/sox-telemetry';
-import { resolveFastembedLockPath } from './fastembedLock.js';
+import { log, forkChild, _recordChildTelemetry, currentRuntimeState } from '@adhd/sox-telemetry';
+import { resolveFastembedLockPath, resolveFastembedServiceLabel } from './fastembedLock.js';
+import { attachOnnxStderrFilter } from './onnxStderrFilter.js';
 const __dirname = dirname(fileURLToPath(import.meta.url));
 /**
  * Resolve `fastembedProcessHost.js` regardless of whether this module is
@@ -97,12 +98,14 @@ const COMPETING_HOST_CACHE_TTL_MS = 3000;
 let _competingHostCache = null;
 let _competingHostCacheOwnPid;
 let _competingHostCacheOwnPoolGroup;
+let _competingHostCacheOwnService;
 let _competingHostCacheAt = -Infinity;
 /** TEST-ONLY: clear the TTL cache so a test can force a fresh fs read. */
 export function __resetCompetingHostCacheForTests() {
     _competingHostCache = null;
     _competingHostCacheOwnPid = undefined;
     _competingHostCacheOwnPoolGroup = undefined;
+    _competingHostCacheOwnService = undefined;
     _competingHostCacheAt = -Infinity;
 }
 /**
@@ -116,17 +119,26 @@ export function __resetCompetingHostCacheForTests() {
  * `competing_host_pid` telemetry field would read as permanently "contended"
  * for every pooled request, which is exactly the false-positive noise BL-331's
  * own postmortem warns against trusting.
+ *
+ * (BL-432) `ownService`, when supplied, does the same for SERVICE identity: a
+ * lock entry whose `service` equals our own is the sequential-CLI false
+ * positive (our own service's earlier/second host), not cross-service
+ * contention, and is suppressed. Requires BOTH sides to carry a real identity —
+ * `ownService === undefined` or an unlabelled/old lock keeps the original
+ * behaviour. The returned `service` is `null` when the lock carries none.
  */
-export function detectCompetingFastembedHost(ownPid, ownPoolGroup) {
+export function detectCompetingFastembedHost(ownPid, ownPoolGroup, ownService) {
     const now = performance.now();
     if (now - _competingHostCacheAt < COMPETING_HOST_CACHE_TTL_MS &&
         _competingHostCacheOwnPid === ownPid &&
-        _competingHostCacheOwnPoolGroup === ownPoolGroup) {
+        _competingHostCacheOwnPoolGroup === ownPoolGroup &&
+        _competingHostCacheOwnService === ownService) {
         return _competingHostCache;
     }
     _competingHostCacheAt = now;
     _competingHostCacheOwnPid = ownPid;
     _competingHostCacheOwnPoolGroup = ownPoolGroup;
+    _competingHostCacheOwnService = ownService;
     try {
         const lockPath = resolveFastembedLockPath();
         if (!existsSync(lockPath)) {
@@ -136,11 +148,17 @@ export function detectCompetingFastembedHost(ownPid, ownPoolGroup) {
         const raw = JSON.parse(readFileSync(lockPath, 'utf8'));
         const pid = typeof raw.pid === 'number' ? raw.pid : null;
         const isKnownPoolSibling = typeof raw.poolGroup === 'string' && ownPoolGroup !== undefined && raw.poolGroup === ownPoolGroup;
-        if (pid === null || pid === ownPid || !isPidAlive(pid) || isKnownPoolSibling) {
+        // (BL-432) Same-service suppression — see this function's doc comment.
+        const isSameService = typeof raw.service === 'string' && ownService !== undefined && raw.service === ownService;
+        if (pid === null || pid === ownPid || !isPidAlive(pid) || isKnownPoolSibling || isSameService) {
             _competingHostCache = null;
             return null;
         }
-        _competingHostCache = { pid, startedAt: typeof raw.startedAt === 'string' ? raw.startedAt : 'unknown' };
+        _competingHostCache = {
+            pid,
+            startedAt: typeof raw.startedAt === 'string' ? raw.startedAt : 'unknown',
+            service: typeof raw.service === 'string' ? raw.service : null,
+        };
         return _competingHostCache;
     }
     catch {
@@ -317,17 +335,53 @@ export class SharedFastembedProcessClient {
             return this.startingPromise;
         this.startingPromise = new Promise((resolveStart) => {
             const hostPath = this.hostPath ?? resolveFastembedHostPath();
-            const c = fork(hostPath, [], {
-                stdio: ['ignore', 'inherit', 'inherit', 'ipc'],
+            // (BL-432) This client's owning-service identity, forwarded to the child
+            // via `SOX_FASTEMBED_SERVICE` so the BL-331 lock it writes names the
+            // SERVICE, and so same-service locks can be suppressed. Resolved from the
+            // parent's own telemetry service (`currentRuntimeState().service`), or a
+            // propagated `SOX_FASTEMBED_SERVICE` if one is already set on us.
+            const childService = resolveFastembedServiceLabel(currentRuntimeState().service);
+            const c = forkChild(hostPath, { service: 'embedding-provider', role: 'harness', logSink: 'file' }, {
+                // (BUG-EMBED-ONNX-COREML-STDERR-NOISE-001) stderr is 'pipe', not
+                // 'inherit' — see `onnxStderrFilter.ts`'s doc comment for why: the
+                // native onnxruntime CoreML EP logs a known-benign "CoreML does not
+                // support input dim > 16384" warning on every model load (bge-base's
+                // {30522,768} word_embeddings tensor), and it must be dropped
+                // without touching any other line (the BL-331 competing-host
+                // warning and the forced-execution-provider line above both go
+                // through `console.error` in the SAME child and must reach the
+                // real terminal unmodified). stdout stays 'inherit' — this package
+                // never wanted stdout piped, only stderr filtered.
+                stdio: ['ignore', 'inherit', 'pipe', 'ipc'],
                 // Real inference is CPU-bound in native code; no need to keep the
                 // parent process alive on this child's account.
                 detached: false,
-                ...(this.poolGroup !== undefined
-                    ? { env: { ...process.env, SOX_FASTEMBED_POOL_GROUP: this.poolGroup } }
-                    : {}),
+                env: {
+                    ...process.env,
+                    ...(this.poolGroup !== undefined ? { SOX_FASTEMBED_POOL_GROUP: this.poolGroup } : {}),
+                    ...(childService !== undefined ? { SOX_FASTEMBED_SERVICE: childService } : {}),
+                },
+            });
+            if (c.stderr)
+                attachOnnxStderrFilter(c.stderr);
+            _recordChildTelemetry({
+                service: 'embedding-provider',
+                role: 'harness',
+                logSink: 'file',
+                filePath: null,
+                pid: c.pid ?? 0,
+                source: 'embedding-provider',
             });
             c.unref();
             c.on('message', (msg) => {
+                // BL-618: the child's telemetry.ready ack carries no request `id` — it
+                // must be handled BEFORE the pending lookup, and it never settles a
+                // pending request, only records the child's telemetry state.
+                const ready = msg;
+                if (ready.type === 'telemetry.ready' && ready.telemetry && typeof ready.telemetry === 'object') {
+                    _recordChildTelemetry({ ...ready.telemetry, source: 'embedding-provider', acked: true });
+                    return;
+                }
                 const pending = this.pending.get(msg.id);
                 if (!pending)
                     return;
@@ -385,6 +439,19 @@ export class SharedFastembedProcessClient {
             // idle at 0% CPU. Cross-process ANE contention remains unproven; the
             // measured cause of the live slowdown was scheduling QoS (BL-331).
             c.channel?.unref();
+            // (BUG-EMBED-ONNX-COREML-STDERR-NOISE-001) Same BL-370 lesson applies to
+            // the new 'pipe' stderr handle: attaching the 'data' listener inside
+            // `attachOnnxStderrFilter()` puts the underlying Socket into flowing
+            // mode, which re-refs it — re-assert `unref()` here so a standalone
+            // script with no other outstanding work can still exit promptly instead
+            // of hanging on this pipe forever. `child.stderr` is typed as a plain
+            // `Readable`, but for `stdio: 'pipe'` it is actually a `net.Socket`
+            // (which alone carries `unref()`) — narrowed via a structural check
+            // instead of a blind cast so a future Node stdio-shape change fails
+            // safe (silently skips the unref) rather than throwing.
+            const stderrHandle = c.stderr;
+            if (typeof stderrHandle?.unref === 'function')
+                stderrHandle.unref();
             this.child = c;
             resolveStart(c);
         });
@@ -437,9 +504,12 @@ export class SharedFastembedProcessClient {
      *      `queue_depth` > 0 alongside a `response_ms` that scales with it) is
      *      distinguishable from "the child itself was slow on a solo request"
      *      (`queue_depth` === 0 with a large `response_ms`).
-     *   3. `competing_host_pid` — present only when a second, still-live
-     *      `fastembedProcessHost` process is detected (BL-331's advisory lock),
-     *      since that changes embed latency 25-50x independent of queueing.
+     *   3. `competing_host_pid` (+ `competing_host_service`, BL-432) — present
+     *      only when a second, still-live `fastembedProcessHost` process belonging
+     *      to a DIFFERENT service is detected (BL-331's advisory lock), since
+     *      that changes embed latency 25-50x independent of queueing. A
+     *      same-service lock (the sequential-CLI false positive) is suppressed,
+     *      so this field means genuine cross-service contention.
      *
      * BL-576: `signal`, when supplied, is an external cancellation source —
      * e.g. `operation-guard.ts`'s `withOperationDeadline` abort controller, so
@@ -488,10 +558,19 @@ export class SharedFastembedProcessClient {
         }
         const id = this.nextId++;
         const queueDepth = this.pending.size;
-        const competing = detectCompetingFastembedHost(child.pid, this.poolGroup);
+        // (BL-432) Our own service identity, so `detectCompetingFastembedHost` can
+        // suppress a same-service lock (the sequential-CLI false positive) while
+        // still reporting genuine cross-service contention with identity.
+        const ownService = resolveFastembedServiceLabel(currentRuntimeState().service);
+        const competing = detectCompetingFastembedHost(child.pid, this.poolGroup, ownService);
         const baseFields = {
             queue_depth: queueDepth,
-            ...(competing ? { competing_host_pid: competing.pid } : {}),
+            ...(competing
+                ? {
+                    competing_host_pid: competing.pid,
+                    competing_host_service: competing.service ?? 'unknown',
+                }
+                : {}),
             // (BUG-EMBED-POOL-SIZE-DARWIN-FREEMEM-001) See the constructor's
             // `poolSize`/`memberIndex` doc comment: makes "was this process even
             // pooled, and at what size" a directly observable telemetry field
@@ -1371,4 +1450,35 @@ export function getSharedFastembedProcess() {
 export function __resetSharedFastembedProcessForTests() {
     _singleton = null;
 }
+/**
+ * (BUG-MEMORYSERVER-EMBED-HEAL-NOOPERATOR-001) Kill AND clear the shared
+ * fastembed host singleton, so the next `getSharedFastembedProcess()` forks a
+ * genuinely fresh child process (and re-inits the model). This is the
+ * embedding-provider half of memory-core's `reinitEmbedProvider()` — the
+ * self-heal path that recovers a wedged fastembed child (BUG-021's
+ * "Model not initialized" respawn-without-reinit state) by tearing the whole
+ * shared host down and re-forking from scratch, rather than waiting for the
+ * dead child to be reaped.
+ *
+ * Unlike `__resetSharedFastembedProcessForTests` (test-only, does NOT
+ * terminate), this TERMINATES the existing singleton first — killing the child
+ * process(es) via the normal `terminate()` shutdown sequence (BL-405's clean
+ * `__shutdown` message, `kill()` fallback) — and only then drops the singleton
+ * reference. Safe to call when no singleton has ever been constructed (no-op).
+ * Any in-flight request is rejected with the standard termination error, which
+ * the heal loop surfaces as a row failure — never a hang.
+ */
+export async function resetSharedFastembedProcess() {
+    const prev = _singleton;
+    _singleton = null;
+    if (prev) {
+        try {
+            await prev.terminate();
+        }
+        catch {
+            // Terminate must never throw into the reset path — the singleton is
+            // already dropped; a best-effort kill is all that remains.
+        }
+    }
+}
 //# sourceMappingURL=sharedFastembedProcess.js.map