@remnic/capture-audio 9.54.2 → 9.54.3

package/dist/cli-bin.js

@@ -2,7 +2,7 @@
 // openclaw-engram: Local-first memory plugin
 import {
   runCapture
-} from "./chunk-BRVXKUZY.js";
+} from "./chunk-MFWH245M.js";
 
 // src/cli-bin.ts
 runCapture({ argv: process.argv.slice(2) }).then((code) => {

package/dist/index.d.ts

@@ -12,7 +12,7 @@ declare const CAPTURE_AUDIO_VERSION = "9.14.0";
 declare const DEFAULT_HOST = "127.0.0.1";
 declare const DEFAULT_PORT = 4340;
 /** Spool schema version, persisted in the `meta` table. */
-declare const SPOOL_SCHEMA_VERSION = 1;
+declare const SPOOL_SCHEMA_VERSION = 2;
 
 /**
  * Error taxonomy for @remnic/capture-audio.
@@ -68,6 +68,15 @@ interface DaemonConfig {
     chunkSeconds: number;
     captureChannel: "mic" | "system" | "both";
     conversationGapMinutes: number;
+    /**
+     * Bounded reorder window, in seconds, for cross-channel arrival skew
+     * (issue #2145). Chunks are held until the newest observed chunk end is
+     * this far past their own end, then released oldest-first, so a delayed
+     * system chunk is grouped with the conversation it belongs to instead of
+     * a later mic chunk's. 0 disables buffering: every chunk is released on
+     * arrival, which is the pre-#2145 behavior.
+     */
+    reorderWindowSeconds: number;
     rawRetentionHours: number;
     spoolRetentionDays: number;
     vad: VadConfig;
@@ -158,6 +167,13 @@ type ChunkStatus = "pending" | "transcribed" | "failed" | "deleted";
 interface SegmentInput {
     speakerCluster?: string | null;
     isWearer?: boolean;
+    /**
+     * Speaker embedding for this segment, persisted as a JSON BLOB (issue
+     * #2145). Clustering runs at finalize over the segments that SURVIVE
+     * cross-channel dedup, so a pruned loopback duplicate never inflates a
+     * cluster's centroid or count.
+     */
+    embedding?: readonly number[] | null;
     channel: string;
     text: string;
     startUtc: string;
@@ -287,8 +303,82 @@ declare class Spool {
      * segment_count in sync. Returns the number actually removed.
      */
     deleteSegments(ids: readonly string[]): number;
+    /**
+     * Segments of one conversation that still need a speaker, chronological.
+     *
+     * Only rows with a stored embedding and no cluster yet: clustering runs at
+     * finalize over the segments that SURVIVED dedup (issue #2145), and skipping
+     * already-assigned rows keeps a repeated finalize from double-counting a
+     * centroid.
+     */
+    conversationSegmentsForDiarization(conversationId: string): Array<{
+        id: string;
+        channel: string;
+        embedding: number[];
+    }>;
+    /**
+     * Commit one conversation's diarization: cluster snapshots and the segment
+     * assignments that produced them, in ONE transaction.
+     *
+     * Splitting the two lets a crash persist an updated `embedding_count` while
+     * its segments stay unassigned; the next finalize would select the same rows
+     * and count the same embeddings again (issue #2145). Atomicity is what makes
+     * the repeated-finalize idempotency claim true.
+     */
+    commitDiarization(input: {
+        clusters: readonly SpeakerInput[];
+        assignments: ReadonlyArray<{
+            id: string;
+            speakerCluster: string;
+            isWearer: boolean;
+        }>;
+    }): number;
     /** Ids of every still-`capturing` conversation (dedup-before-finalize sweep). */
     capturingConversationIds(): string[];
+    /**
+     * Record a bare idempotency marker (no segments).
+     *
+     * Used to persist facts a later replay cannot re-derive — such as how many
+     * segments a chunk's transcript produced, which is the only way to tell a
+     * legitimately shorter retranscription from a missing tail (issue #2145).
+     */
+    markApplied(idempotencyKey: string, conversationId: string): void;
+    /**
+     * Whether ANY idempotency key for this chunk was applied.
+     *
+     * Only a SILENT replay needs this — a chunk partially applied by a binary
+     * predating the transcript manifest has no manifest to compare, and a
+     * zero-segment replay has no per-segment key to look up exactly. Speech
+     * chunks use the indexed manifest lookup below, so continuous capture never
+     * pays for this scan (issue #2145).
+     */
+    hasAppliedChunkPrefix(chunkIdPrefix: string): boolean;
+    /**
+     * Conversations a chunk actually contributed stored segments to.
+     *
+     * Used to scope a rebuilt replay hold to the prefix that chunk belongs to,
+     * rather than to every conversation that happens to be capturing (#2145).
+     * Matches the bare chunk id and every per-segment or per-group derivative
+     * (`<chunkId>:h<hash>`, and the pre-manifest `<chunkId>:<n>`).
+     */
+    conversationIdsForChunk(chunkId: string): string[];
+    /**
+     * Chunks whose transcript manifest is recorded but which never completed.
+     *
+     * A restart loses the in-memory record of which chunks are still awaiting a
+     * replay, so it is re-derived from these two durable markers: the manifest is
+     * written before any append, `:done` only after every segment is stored
+     * (issue #2145).
+     */
+    incompleteChunkIds(): string[];
+    /**
+     * The value stored alongside an idempotency marker, or `undefined`.
+     *
+     * `markApplied` uses this column to carry a fact a replay cannot re-derive —
+     * the chunk's transcript manifest hash — and this is the exact, primary-key
+     * lookup that reads it back (issue #2145).
+     */
+    appliedChunkValue(idempotencyKey: string): string | undefined;
     /** Whether a chunk with this idempotency key was already durably applied. */
     isChunkApplied(idempotencyKey: string): boolean;
     /**
@@ -307,6 +397,12 @@ declare class Spool {
         startedAtUtc: string;
         endedAtUtc: string;
     } | null;
+    /** One capturing conversation by id, for resuming a specific prefix. */
+    capturingConversationById(id: string): {
+        id: string;
+        startedAtUtc: string;
+        endedAtUtc: string;
+    } | null;
     upsertSpeaker(input: SpeakerInput): void;
     /** Read every speaker cluster with decoded centroid + examples (diarization restart seed). */
     readSpeakerClusters(): SpeakerClusterRow[];
@@ -686,6 +782,27 @@ declare class ConversationAssembler {
         startedAtUtc: string;
         endedAtUtc: string;
     }): void;
+    /**
+     * Drop finalized conversations the caller no longer needs.
+     *
+     * A long-running daemon would otherwise retain every conversation and every
+     * segment forever, which makes the rollback snapshot below O(capture
+     * history) and the daemon's per-chunk work quadratic (issue #2145). Only the
+     * open conversation can still be mutated, so nothing else needs keeping.
+     */
+    pruneFinalized(): number;
+    /**
+     * Deep snapshot for rollback (issue #2145).
+     *
+     * `add` mutates the open conversation in place. A caller that fails BEFORE
+     * anything was persisted must be able to rewind, or the retry feeds earlier
+     * timestamps into an advanced assembler and collapses conversations the
+     * first attempt had split. A caller that already persisted something must
+     * NOT rewind: the durable ids would then diverge from the in-memory ones.
+     */
+    checkpoint(): AssembledConversation[];
+    /** Rewind to a {@link checkpoint}. */
+    rewind(snapshot: readonly AssembledConversation[]): void;
     /** Ordered snapshot; segments are cloned so callers cannot mutate internal state. */
     conversations(): AssembledConversation[];
     /**
@@ -733,6 +850,15 @@ declare class SpeakerClusterer {
     enrollSelf(embedding: Embedding): void;
     /** Match `embedding` to an existing cluster or create a new `spk_<n>`. */
     assign(embedding: Embedding): string;
+    /**
+     * Replace every cluster with `snapshot` (issue #2145).
+     *
+     * `assign` mutates centroids and counts in place, so a diarization commit
+     * that rolls back in SQLite must roll back here too — otherwise the retry
+     * counts the same embeddings twice. Deep-copied, so the caller's snapshot
+     * cannot alias internal state.
+     */
+    restore(snapshot: readonly SpeakerCluster[]): void;
     /** Snapshot for persistence. */
     clusters(): SpeakerCluster[];
 }
@@ -927,6 +1053,15 @@ interface ChunkProcessorDeps {
     diarizer?: SpeakerClusterer;
     /** Cross-channel dedup window in ms; defaults to the dedup module's tolerance. */
     dedupWindowMs?: number;
+    /**
+     * Bounded reorder window in ms for cross-channel arrival skew (issue
+     * #2145). A transcribed chunk is HELD until the newest observed chunk end
+     * is this far past its own end, then released oldest-first, so a delayed
+     * system chunk is assembled into the conversation it temporally belongs to
+     * rather than joined to a later mic chunk's. 0 (the default here, so
+     * existing callers are unchanged) releases every chunk on arrival.
+     */
+    reorderWindowMs?: number;
     /** Reports a per-chunk failure; the chain keeps running afterwards. */
     onError?: (error: Error, event: ChunkEvent) => void;
 }
@@ -938,11 +1073,6 @@ interface ChunkProcessor {
     /** Drain, then flip open conversations to `final`; returns the count closed. */
     finalize(): Promise<number>;
 }
-/**
- * Stable chunk identity derived purely from the WAV path. Because it never
- * depends on a freshly-generated conversation id, the same chunk yields the
- * same idempotency key across process restarts.
- */
 declare function chunkStableId(event: ChunkEvent): string;
 declare function createChunkProcessor(deps: ChunkProcessorDeps): ChunkProcessor;
 

package/dist/index.js

@@ -70,7 +70,7 @@ import {
   whisperModelUrl,
   wordJaccard,
   writePidFile
-} from "./chunk-BRVXKUZY.js";
+} from "./chunk-MFWH245M.js";
 
 // src/vad.ts
 import { statSync } from "fs";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@remnic/capture-audio",
-  "version": "9.54.2",
+  "version": "9.54.3",
   "description": "Desktop audio capture daemon for Remnic — local spool, loopback HTTP API, and replay ingestion for the wearable source `desktop` (à-la-carte)",
   "type": "module",
   "main": "dist/index.js",
@@ -29,13 +29,13 @@
     "tsup": "^8.0.0",
     "typescript": "^5.7.0",
     "tsx": "^4.0.0",
-    "@remnic/core": "9.54.2"
+    "@remnic/core": "9.54.3"
   },
   "peerDependencies": {
-    "@remnic/core": "^9.54.2",
+    "@remnic/core": "^9.54.3",
     "sherpa-onnx-node": "*",
-    "@remnic/capture-native-darwin-arm64": "^9.54.2",
-    "@remnic/capture-native-darwin-x64": "^9.54.2"
+    "@remnic/capture-native-darwin-arm64": "^9.54.3",
+    "@remnic/capture-native-darwin-x64": "^9.54.3"
   },
   "peerDependenciesMeta": {
     "sherpa-onnx-node": {