agentic-qe 3.15.2 → 3.15.4

package/dist/mcp/services/session-store.js

@@ -6,17 +6,35 @@
  * changes within a session. Supports write batching (100ms window) and
  * lazy file creation (no file until first append).
  *
+ * Issue #910: writes track progress byte by byte, so a write that fails partway
+ * (ENOSPC, EIO) resumes where it stopped instead of re-appending what already
+ * reached the disk. The unwritten backlog is bounded while the disk keeps
+ * failing; dropped entries become one gap marker that keeps the transcript
+ * resumable (see session-write-buffer.ts).
+ *
  * @module mcp/services/session-store
  */
 import { randomUUID } from 'crypto';
 import * as fs from 'fs';
 import * as path from 'path';
 import { findProjectRoot } from '../../kernel/project-root.js';
+import { SessionWriteBuffer, encodeEntry } from './session-write-buffer.js';
 // ============================================================================
 // Session Store
 // ============================================================================
 const DEFAULT_SESSION_DIR = '.agentic-qe/sessions';
 const BATCH_FLUSH_MS = 100;
+const DEFAULT_MAX_BUFFERED_ENTRIES = 10_000;
+// Matches the largest transcript session-resume will read.
+const DEFAULT_MAX_BUFFERED_BYTES = 16 * 1024 * 1024;
+function positiveLimit(name, value, fallback) {
+    if (value === undefined)
+        return fallback;
+    if (!Number.isSafeInteger(value) || value <= 0) {
+        throw new RangeError(`SessionStore ${name} must be a positive integer, got ${value}`);
+    }
+    return value;
+}
 export class SessionStore {
     sessionDir;
     sessionId = null;
@@ -27,13 +45,20 @@ export class SessionStore {
     createdAt = 0;
     lastActivityAt = 0;
     currentState = 'idle';
-    writeBuffer = [];
+    /** Lines not yet fully on disk, oldest first. */
+    writeBuffer;
+    dropWarned = false;
+    maxBufferedEntries;
+    maxBufferedBytes;
     flushTimer = null;
     closed = false;
     // Database-free mode (#534): keep session bookkeeping in memory but never
     // write .agentic-qe/sessions/*.jsonl to disk.
     persistDisabled = process.env.AQE_MEMORY_BACKEND === 'memory';
-    constructor(sessionDir) {
+    constructor(sessionDir, options = {}) {
+        this.maxBufferedEntries = positiveLimit('maxBufferedEntries', options.maxBufferedEntries, DEFAULT_MAX_BUFFERED_ENTRIES);
+        this.maxBufferedBytes = positiveLimit('maxBufferedBytes', options.maxBufferedBytes, DEFAULT_MAX_BUFFERED_BYTES);
+        this.writeBuffer = this.createWriteBuffer();
         // #735: a cwd-relative default created `<subdir>/.agentic-qe/sessions`
         // on the first MCP tool call, which later runs then adopted as the
         // nearest project store. Anchor the default at the project root.
@@ -55,7 +80,8 @@ export class SessionStore {
         this.createdAt = Date.now();
         this.lastActivityAt = this.createdAt;
         this.currentState = 'idle';
-        this.writeBuffer = [];
+        this.writeBuffer = this.createWriteBuffer();
+        this.dropWarned = false;
         this.flushTimer = null;
         this.closed = false;
         return this.sessionId;
@@ -65,7 +91,7 @@ export class SessionStore {
      * Assigns a uuid, links parentUuid to the previous entry,
      * and writes a JSON line to the file.
      *
-     * First write uses appendFileSync for write-ahead guarantee.
+     * The first write is synchronous for a write-ahead guarantee.
      * Subsequent writes are batched for up to 100ms before flushing.
      *
      * Returns the assigned uuid.
@@ -82,24 +108,37 @@ export class SessionStore {
         };
         // Database-free mode keeps bookkeeping without serialization or disk I/O.
         if (!this.persistDisabled) {
-            const line = JSON.stringify(fullEntry) + '\n';
+            const line = encodeEntry(fullEntry);
             if (!this.fileCreated) {
                 // First write: synchronous for write-ahead guarantee
                 this.ensureDirectory();
-                fs.appendFileSync(this.filePath, line, 'utf-8');
+                this.writeBuffer.push(fullEntry, line);
+                try {
+                    this.writePending();
+                }
+                catch (error) {
+                    if (!this.writeBuffer.hasPartialHead) {
+                        // Nothing reached the disk: reject the entry and leave the chain as it was.
+                        this.writeBuffer.popNewest();
+                        throw error;
+                    }
+                    // Part of the line is on disk. Keep it so a retry completes the record
+                    // rather than leaving a torn prefix for the next line to glue onto.
+                    this.fileCreated = true;
+                    this.accept(fullEntry);
+                    this.scheduleBatchFlush();
+                    throw error;
+                }
                 this.fileCreated = true;
             }
             else {
                 // Subsequent writes: buffer and batch
-                this.writeBuffer.push(line);
+                this.writeBuffer.push(fullEntry, line);
                 this.scheduleBatchFlush();
             }
         }
         // Only advance the chain and metadata after the entry has been accepted.
-        this.lastUuid = uuid;
-        this.entryCount++;
-        this.lastActivityAt = fullEntry.timestamp;
-        this.currentState = fullEntry.state;
+        this.accept(fullEntry);
         return uuid;
     }
     /**
@@ -110,12 +149,20 @@ export class SessionStore {
             clearTimeout(this.flushTimer);
             this.flushTimer = null;
         }
-        if (this.writeBuffer.length > 0 && this.filePath && this.fileCreated) {
-            const batch = this.writeBuffer.join('');
-            fs.appendFileSync(this.filePath, batch, 'utf-8');
-            this.writeBuffer = [];
+        if (this.fileCreated) {
+            this.writePending();
         }
     }
+    /**
+     * Size of the unwritten backlog and how many entries the cap has dropped.
+     */
+    getWriteBufferStats() {
+        return {
+            bufferedEntries: this.writeBuffer.size,
+            bufferedBytes: this.writeBuffer.bufferedBytes,
+            droppedEntries: this.writeBuffer.droppedEntries,
+        };
+    }
     /**
      * Returns metadata about the current session.
      */
@@ -162,11 +209,43 @@ export class SessionStore {
             fs.mkdirSync(dir, { recursive: true });
         }
     }
+    accept(entry) {
+        this.lastUuid = entry.uuid;
+        this.entryCount++;
+        this.lastActivityAt = entry.timestamp;
+        this.currentState = entry.state;
+    }
+    writePending() {
+        if (this.filePath)
+            this.writeBuffer.writeTo(this.filePath);
+    }
+    createWriteBuffer() {
+        return new SessionWriteBuffer(this.maxBufferedEntries, this.maxBufferedBytes, () => {
+            if (this.dropWarned)
+                return;
+            this.dropWarned = true;
+            // "[AQE] WARN" passes the MCP entry's stderr filter.
+            console.error(`[AQE] WARN session journal ${this.filePath}: writes keep failing and the buffer reached its cap `
+                + `(${this.maxBufferedEntries} entries / ${this.maxBufferedBytes} bytes). The oldest unwritten entries `
+                + 'are replaced by one gap marker: their content is lost, but the transcript stays resumable. '
+                + 'The dropped count is in getWriteBufferStats() and in the marker.');
+        });
+    }
     scheduleBatchFlush() {
         if (this.flushTimer === null) {
             this.flushTimer = setTimeout(() => {
                 this.flushTimer = null;
-                this.flush();
+                try {
+                    this.flush();
+                }
+                catch {
+                    // #983: a throw here has no caller and reaches 'uncaughtException',
+                    // which the MCP entry logs as "[AQE] FATAL" on every tick while the
+                    // disk stays full. The unwritten entries stay buffered for the next
+                    // append or flush(), and the buffer's one-time WARN reports a
+                    // persistent failure once it reaches its cap. An explicit flush() or
+                    // close() still throws to its caller.
+                }
             }, BATCH_FLUSH_MS);
         }
     }

package/dist/mcp/services/session-write-buffer.d.ts

@@ -0,0 +1,55 @@
+/**
+ * Bounded, progress-tracking write buffer for the JSONL session journal (#910).
+ *
+ * - Writes track byte progress, so a write that fails partway (ENOSPC, EIO)
+ *   resumes where it stopped instead of re-appending what reached the disk.
+ * - While writes keep failing, the backlog is capped. The oldest unwritten
+ *   entries are replaced by one `state_change` gap marker that reuses the last
+ *   dropped entry's uuid and the first dropped entry's parentUuid, so the
+ *   parentUuid chain on disk stays valid and session-resume still accepts it.
+ *
+ * @module mcp/services/session-write-buffer
+ */
+import type { SessionEntry } from './session-store';
+/** `result` payload of a gap marker entry. */
+export interface JournalGap {
+    droppedEntries: number;
+    reason: string;
+}
+export declare function encodeEntry(entry: SessionEntry): Buffer;
+export declare class SessionWriteBuffer {
+    private readonly maxEntries;
+    private readonly maxBytes;
+    /** Called once per drop event with the running dropped total. */
+    private readonly onDrop;
+    private lines;
+    /** Bytes of lines[0] already on disk after a write that failed partway. */
+    private headWritten;
+    private bytes;
+    private dropped;
+    constructor(maxEntries: number, maxBytes: number, 
+    /** Called once per drop event with the running dropped total. */
+    onDrop: (droppedTotal: number) => void);
+    get size(): number;
+    get bufferedBytes(): number;
+    get droppedEntries(): number;
+    /** True when part of the oldest line is already on disk. */
+    get hasPartialHead(): boolean;
+    push(entry: SessionEntry, data?: Buffer): void;
+    /** Remove the newest line (an entry whose first write put nothing on disk). */
+    popNewest(): void;
+    /**
+     * Append every buffered line with one write loop over a single buffer, then
+     * map the bytes written back onto line boundaries. On failure only the
+     * unwritten remainder stays buffered.
+     */
+    writeTo(filePath: string): void;
+    /** Drop the lines fully covered by `offset` bytes and keep partial progress. */
+    private settle;
+    /**
+     * Replace the oldest droppable lines with one gap marker until both caps hold.
+     * The newest line and a partially written head line are never dropped.
+     */
+    private enforceCaps;
+}
+//# sourceMappingURL=session-write-buffer.d.ts.map

package/dist/mcp/services/session-write-buffer.js

@@ -0,0 +1,144 @@
+/**
+ * Bounded, progress-tracking write buffer for the JSONL session journal (#910).
+ *
+ * - Writes track byte progress, so a write that fails partway (ENOSPC, EIO)
+ *   resumes where it stopped instead of re-appending what reached the disk.
+ * - While writes keep failing, the backlog is capped. The oldest unwritten
+ *   entries are replaced by one `state_change` gap marker that reuses the last
+ *   dropped entry's uuid and the first dropped entry's parentUuid, so the
+ *   parentUuid chain on disk stays valid and session-resume still accepts it.
+ *
+ * @module mcp/services/session-write-buffer
+ */
+import * as fs from 'fs';
+const GAP_REASON = 'write buffer cap reached while the session journal could not be written';
+// Upper bound on a gap marker line, used while choosing how many lines to drop.
+const GAP_MARKER_MAX_BYTES = 512;
+export function encodeEntry(entry) {
+    return Buffer.from(JSON.stringify(entry) + '\n', 'utf-8');
+}
+export class SessionWriteBuffer {
+    maxEntries;
+    maxBytes;
+    onDrop;
+    lines = [];
+    /** Bytes of lines[0] already on disk after a write that failed partway. */
+    headWritten = 0;
+    bytes = 0;
+    dropped = 0;
+    constructor(maxEntries, maxBytes, 
+    /** Called once per drop event with the running dropped total. */
+    onDrop) {
+        this.maxEntries = maxEntries;
+        this.maxBytes = maxBytes;
+        this.onDrop = onDrop;
+    }
+    get size() { return this.lines.length; }
+    get bufferedBytes() { return this.bytes; }
+    get droppedEntries() { return this.dropped; }
+    /** True when part of the oldest line is already on disk. */
+    get hasPartialHead() { return this.headWritten > 0; }
+    push(entry, data = encodeEntry(entry)) {
+        this.lines.push({
+            data, uuid: entry.uuid, parentUuid: entry.parentUuid,
+            timestamp: entry.timestamp, state: entry.state, represents: 1,
+        });
+        this.bytes += data.length;
+        this.enforceCaps();
+    }
+    /** Remove the newest line (an entry whose first write put nothing on disk). */
+    popNewest() {
+        const line = this.lines.pop();
+        if (line)
+            this.bytes -= line.data.length;
+    }
+    /**
+     * Append every buffered line with one write loop over a single buffer, then
+     * map the bytes written back onto line boundaries. On failure only the
+     * unwritten remainder stays buffered.
+     */
+    writeTo(filePath) {
+        if (this.lines.length === 0)
+            return;
+        const pending = Buffer.concat(this.lines.map(line => line.data));
+        let offset = this.headWritten;
+        const fd = fs.openSync(filePath, 'a');
+        try {
+            while (offset < pending.length) {
+                const count = fs.writeSync(fd, pending, offset, pending.length - offset);
+                if (count <= 0)
+                    throw new Error(`session journal write made no progress: ${filePath}`);
+                offset += count;
+            }
+        }
+        finally {
+            this.settle(offset);
+            try {
+                fs.closeSync(fd);
+            }
+            catch {
+                // The bytes were handed to the kernel already; a write error, if any,
+                // is the one worth reporting.
+            }
+        }
+    }
+    /** Drop the lines fully covered by `offset` bytes and keep partial progress. */
+    settle(offset) {
+        let completed = 0;
+        let consumed = 0;
+        while (completed < this.lines.length && consumed + this.lines[completed].data.length <= offset) {
+            consumed += this.lines[completed].data.length;
+            completed++;
+        }
+        if (completed > 0) {
+            this.lines.splice(0, completed);
+            this.bytes -= consumed;
+        }
+        this.headWritten = offset - consumed;
+    }
+    /**
+     * Replace the oldest droppable lines with one gap marker until both caps hold.
+     * The newest line and a partially written head line are never dropped.
+     */
+    enforceCaps() {
+        const start = this.headWritten > 0 ? 1 : 0;
+        const newest = this.lines.length - 1;
+        let end = start;
+        let removedBytes = 0;
+        const over = () => {
+            const removed = end - start;
+            const marker = removed > 0 ? 1 : 0;
+            return this.lines.length - removed + marker > this.maxEntries
+                || this.bytes - removedBytes + marker * GAP_MARKER_MAX_BYTES > this.maxBytes;
+        };
+        if (!over())
+            return;
+        while (end < newest && over()) {
+            removedBytes += this.lines[end].data.length;
+            end++;
+        }
+        // Swapping a single line for a marker frees nothing (caps below 2 lines).
+        if (end - start < 2)
+            return;
+        const run = this.lines.slice(start, end);
+        const first = run[0];
+        const last = run[run.length - 1];
+        const represents = run.reduce((sum, line) => sum + line.represents, 0);
+        // An earlier marker inside the run was already counted.
+        const newlyDropped = run.filter(line => line.represents === 1).length;
+        const gap = { droppedEntries: represents, reason: GAP_REASON };
+        const markerEntry = {
+            uuid: last.uuid, parentUuid: first.parentUuid, timestamp: last.timestamp,
+            type: 'state_change', state: last.state, result: { journalGap: gap },
+        };
+        const data = encodeEntry(markerEntry);
+        this.lines.splice(start, run.length, {
+            data, uuid: last.uuid, parentUuid: first.parentUuid,
+            timestamp: last.timestamp, state: last.state, represents,
+        });
+        this.bytes += data.length - removedBytes;
+        this.dropped += newlyDropped;
+        this.onDrop(this.dropped);
+    }
+}
+//# sourceMappingURL=session-write-buffer.js.map

package/dist/mcp/types.d.ts

@@ -199,6 +199,8 @@ export interface TestExecuteParams {
     timeout?: number;
     collectCoverage?: boolean;
     reportFormat?: 'json' | 'junit' | 'html' | 'markdown';
+    /** #933: write result files under .agentic-qe/results/ (default true). false skips them. */
+    saveResults?: boolean;
 }
 /**
  * Coverage analysis parameters
@@ -209,6 +211,8 @@ export interface CoverageAnalyzeParams {
     detectGaps?: boolean;
     mlPowered?: boolean;
     prioritization?: 'complexity' | 'criticality' | 'change-frequency' | 'ml-confidence';
+    /** #933: write result files under .agentic-qe/results/ (default true). false skips them. */
+    saveResults?: boolean;
 }
 /**
  * Quality assessment parameters
@@ -217,6 +221,8 @@ export interface QualityAssessParams {
     runGate?: boolean;
     threshold?: number;
     metrics?: string[];
+    /** #933: write result files under .agentic-qe/results/ (default true). false skips them. */
+    saveResults?: boolean;
 }
 /**
  * Security scan parameters
@@ -228,6 +234,8 @@ export interface SecurityScanParams {
     target?: string;
     /** URL for explicitly requested dynamic scanning. */
     targetUrl?: string;
+    /** #933: write result files under .agentic-qe/results/ (default true). false skips them. */
+    saveResults?: boolean;
 }
 /**
  * Contract validation parameters
@@ -237,6 +245,8 @@ export interface ContractValidateParams {
     providerUrl?: string;
     consumerName?: string;
     checkBreakingChanges?: boolean;
+    /** #933: write result files under .agentic-qe/results/ (default true). false skips them. */
+    saveResults?: boolean;
 }
 /**
  * Accessibility test parameters
@@ -245,6 +255,8 @@ export interface AccessibilityTestParams {
     url?: string;
     standard?: 'wcag21-aa' | 'wcag21-aaa' | 'wcag22-aa' | 'section508';
     includeScreenReader?: boolean;
+    /** #933: write result files under .agentic-qe/results/ (default true). false skips them. */
+    saveResults?: boolean;
 }
 /**
  * Chaos test parameters
@@ -255,6 +267,8 @@ export interface ChaosTestParams {
     duration?: number;
     intensity?: number;
     dryRun?: boolean;
+    /** #933: write result files under .agentic-qe/results/ (default true). false skips them. */
+    saveResults?: boolean;
 }
 /**
  * Protocol execute parameters
@@ -528,6 +542,10 @@ export interface CoverageAnalyzeResult {
     gaps?: CoverageGap[];
     riskScore?: number;
     savedFiles?: string[];
+    /** #933: true when result files were written; see savedFiles for their paths. */
+    resultsSaved?: boolean;
+    /** #933: plain statement of what was (or was not) written to disk. */
+    resultsNote?: string;
     /** #569: `null` when no figure was produced — see `lineCoverage`. */
     statementCoverage?: number | null;
     totalFiles?: number;

package/dist/memory/crdt/convergence-tracker.js

@@ -7,6 +7,7 @@
  *
  * @module memory/crdt/convergence-tracker
  */
+import { createHash } from 'node:crypto';
 // =============================================================================
 // Default Configuration
 // =============================================================================
@@ -23,7 +24,7 @@ const DEFAULT_CONFIG = {
  * not the internal representations, so that stores with equivalent data produce
  * the same hash regardless of how they arrived at that state.
  *
- * Not cryptographic - just for detecting differences.
+ * Fingerprints structured semantic entries; this is not authentication.
  */
 function hashState(state) {
     const parts = [];
@@ -31,7 +32,7 @@ function hashState(state) {
     // compare the result - if both have same winner, they have same value)
     for (const [key, reg] of Object.entries(state.registers)) {
         // Include value, timestamp, and nodeId - these together determine the LWW winner
-        parts.push(`r:${key}:${JSON.stringify(reg.value)}:${reg.timestamp}:${reg.nodeId}`);
+        parts.push(JSON.stringify(['r', key, JSON.stringify(reg.value), reg.timestamp, reg.nodeId]));
     }
     // Hash G-Counters by their TOTAL value (not per-node breakdown)
     // Two stores are converged if they produce the same sum, even if the internal
@@ -41,10 +42,9 @@ function hashState(state) {
         // Also include non-zero counts to detect semantic differences
         const nonZeroCounts = Object.entries(counter.counts)
             .filter(([_, count]) => count > 0)
-            .sort(([a], [b]) => a.localeCompare(b))
-            .map(([nodeId, count]) => `${nodeId}=${count}`)
-            .join(',');
-        parts.push(`g:${key}:${total}:{${nonZeroCounts}}`);
+            .sort(([a], [b]) => a === b ? 0 : a < b ? -1 : 1)
+            .map(([nodeId, count]) => [nodeId, count]);
+        parts.push(JSON.stringify(['g', key, total, nonZeroCounts]));
     }
     // Hash PN-Counters by their NET value (positive - negative)
     // Two stores are converged if they evaluate to the same number
@@ -55,15 +55,13 @@ function hashState(state) {
         // Include non-zero contributions for semantic comparison
         const nonZeroPos = Object.entries(counter.positive.counts)
             .filter(([_, count]) => count > 0)
-            .sort(([a], [b]) => a.localeCompare(b))
-            .map(([nodeId, count]) => `${nodeId}=+${count}`)
-            .join(',');
+            .sort(([a], [b]) => a === b ? 0 : a < b ? -1 : 1)
+            .map(([nodeId, count]) => [nodeId, count]);
         const nonZeroNeg = Object.entries(counter.negative.counts)
             .filter(([_, count]) => count > 0)
-            .sort(([a], [b]) => a.localeCompare(b))
-            .map(([nodeId, count]) => `${nodeId}=-${count}`)
-            .join(',');
-        parts.push(`p:${key}:${netValue}:{${nonZeroPos}|${nonZeroNeg}}`);
+            .sort(([a], [b]) => a === b ? 0 : a < b ? -1 : 1)
+            .map(([nodeId, count]) => [nodeId, count]);
+        parts.push(JSON.stringify(['p', key, netValue, nonZeroPos, nonZeroNeg]));
     }
     // Hash OR-Sets by their active elements (elements with at least one non-tombstoned tag)
     for (const [key, set] of Object.entries(state.sets)) {
@@ -77,20 +75,12 @@ function hashState(state) {
             }
         }
         activeElements.sort();
-        parts.push(`s:${key}:[${activeElements.join(',')}]`);
+        parts.push(JSON.stringify(['s', key, activeElements]));
     }
     // Sort for consistency
     parts.sort();
-    // Simple hash: join and get a fingerprint
-    const joined = parts.join('|');
-    let hash = 0;
-    for (let i = 0; i < joined.length; i++) {
-        const char = joined.charCodeAt(i);
-        hash = ((hash << 5) - hash) + char;
-        hash = hash & hash; // Convert to 32-bit integer
-    }
-    // Return hash without version - version is per-node and shouldn't affect convergence check
-    return hash.toString(16);
+    // Version is per-node and does not affect semantic convergence.
+    return createHash('sha256').update(JSON.stringify(parts)).digest('hex');
 }
 // =============================================================================
 // Convergence Tracker Implementation

package/dist/memory/crdt/crdt-store.js

@@ -365,6 +365,21 @@ export function createCRDTStore(config) {
                 // For initial state, need full state - caller should use getState instead
                 return null;
             }
+            // A retained suffix cannot cover an older checkpoint. Send complete CRDT
+            // state (including OR-set tombstones) through the existing delta merge API.
+            if (sinceVersion < deltaHistory[0].fromVersion) {
+                const snapshot = store.getState();
+                return {
+                    fromVersion: sinceVersion,
+                    toVersion: version,
+                    timestamp: Date.now(),
+                    nodeId,
+                    registers: snapshot.registers,
+                    gCounters: snapshot.gCounters,
+                    pnCounters: snapshot.pnCounters,
+                    sets: snapshot.sets,
+                };
+            }
             // Find deltas that contain changes after the requested version
             // A delta is relevant if its toVersion > sinceVersion
             const relevantDeltas = deltaHistory.filter((d) => d.toVersion > sinceVersion);

package/dist/memory/crdt/g-counter.js

@@ -7,6 +7,7 @@
  *
  * @module memory/crdt/g-counter
  */
+import { addToCount, createSafeRecord, getOwn, setOwn } from '../../shared/utils/safe-record.js';
 // =============================================================================
 // G-Counter Implementation
 // =============================================================================
@@ -27,12 +28,13 @@
 export function createGCounter(nodeId) {
     // Internal state: per-node counts
     const state = {
-        counts: {},
+        // Node ids are data: keep them off Object.prototype (#914).
+        counts: createSafeRecord(),
         version: 0,
         lastUpdated: Date.now(),
     };
     // Initialize this node's count
-    state.counts[nodeId] = 0;
+    setOwn(state.counts, nodeId, 0);
     return {
         get() {
             // Sum all node counts
@@ -45,7 +47,7 @@ export function createGCounter(nodeId) {
             if (n === 0) {
                 return;
             }
-            state.counts[nodeId] = (state.counts[nodeId] || 0) + n;
+            addToCount(state.counts, nodeId, n);
             state.version++;
             state.lastUpdated = Date.now();
         },
@@ -56,7 +58,7 @@ export function createGCounter(nodeId) {
         getState() {
             // Return a deep copy to prevent external mutation
             return {
-                counts: { ...state.counts },
+                counts: Object.assign(createSafeRecord(), state.counts),
                 version: state.version,
                 lastUpdated: state.lastUpdated,
             };
@@ -65,9 +67,9 @@ export function createGCounter(nodeId) {
             let changed = false;
             // Merge counts: take max for each node
             for (const [incomingNodeId, incomingCount] of Object.entries(incoming.counts)) {
-                const currentCount = state.counts[incomingNodeId] || 0;
+                const currentCount = getOwn(state.counts, incomingNodeId) ?? 0;
                 if (incomingCount > currentCount) {
-                    state.counts[incomingNodeId] = incomingCount;
+                    setOwn(state.counts, incomingNodeId, incomingCount);
                     changed = true;
                 }
             }
@@ -80,7 +82,7 @@ export function createGCounter(nodeId) {
             return nodeId;
         },
         getLocalCount() {
-            return state.counts[nodeId] || 0;
+            return getOwn(state.counts, nodeId) ?? 0;
         },
     };
 }
@@ -123,7 +125,7 @@ export function isGCounterState(value) {
  * Get the count for a specific node from state
  */
 export function getNodeCountFromState(state, nodeId) {
-    return state.counts[nodeId] || 0;
+    return getOwn(state.counts, nodeId) ?? 0;
 }
 /**
  * Get all contributing nodes from state

package/dist/memory/crdt/lww-register.js

@@ -43,7 +43,7 @@ export function createLWWRegister(nodeId, initialValue, initialTimestamp) {
             return timestampA - timestampB;
         }
         // Tiebreaker: lexicographic comparison of node IDs
-        return nodeIdA.localeCompare(nodeIdB);
+        return nodeIdA === nodeIdB ? 0 : nodeIdA > nodeIdB ? 1 : -1;
     }
     return {
         get() {
@@ -52,7 +52,7 @@ export function createLWWRegister(nodeId, initialValue, initialTimestamp) {
         set(value, timestamp) {
             const ts = timestamp ?? Date.now();
             // Only update if new timestamp wins
-            if (state.timestamp === 0 ||
+            if (state.version === 0 ||
                 compareTimestamps(ts, nodeId, state.timestamp, state.nodeId) > 0) {
                 state = {
                     value,
@@ -79,7 +79,7 @@ export function createLWWRegister(nodeId, initialValue, initialTimestamp) {
         },
         applyState(incoming) {
             // Only update if incoming timestamp wins
-            if (state.timestamp === 0 ||
+            if (state.version === 0 ||
                 compareTimestamps(incoming.timestamp, incoming.nodeId, state.timestamp, state.nodeId) > 0) {
                 state = {
                     value: incoming.value,