@thehammer/danx-session-telemetry 0.1.16 → 0.1.17

package/dist/dispatch-usage.d.ts

@@ -50,6 +50,13 @@ export declare class DispatchUsage {
      */
     private startCursors;
     private startCursorsPersisted;
+    /**
+     * DX-2954 — set the moment the first flush begins. `attachCursors` after that
+     * point would set the starting cursors AFTER a write that carried none, and
+     * `startCursorsPersisted` (set by any landed write) would then keep them from
+     * ever being carried — the exact AC 34324 loss, silently. So it fails loud.
+     */
+    private flushBegan;
     /** Past-EOF resets to report once, then forget. */
     private pastEof;
     /**
@@ -134,7 +141,7 @@ export declare class DispatchUsage {
      *
      * So every source in the cursors this process STARTED from that the watcher
      * has not opened yet is reported VERBATIM — the exact `{acked, delivered}`
-     * pair it resumed from — until one write carrying them has landed. That is
+     * pair it resumed from — until a write that carries them has landed. That is
      * what makes "every attach persists its starting cursors" true on the FIRST
      * write rather than one stats tick (15-30 s) later: a reattach of this row
      * inside its first interval reads them back (start-order rule 1) and starts

package/dist/dispatch-usage.js

@@ -70,6 +70,13 @@ export class DispatchUsage {
      */
     startCursors = {};
     startCursorsPersisted = false;
+    /**
+     * DX-2954 — set the moment the first flush begins. `attachCursors` after that
+     * point would set the starting cursors AFTER a write that carried none, and
+     * `startCursorsPersisted` (set by any landed write) would then keep them from
+     * ever being carried — the exact AC 34324 loss, silently. So it fails loud.
+     */
+    flushBegan = false;
     /** Past-EOF resets to report once, then forget. */
     pastEof = [];
     /**
@@ -93,6 +100,11 @@ export class DispatchUsage {
      * each write.
      */
     attachCursors(readCursorState, startCursors) {
+        // DX-2954 (AC 34324): the starting cursors ride the process-start write, so
+        // they must be attached BEFORE any write is attempted.
+        if (this.flushBegan) {
+            throw new Error("DispatchUsage.attachCursors: called after the first stats write began — the starting cursors would never be persisted");
+        }
         this.readCursorState = readCursorState;
         this.startCursors = startCursors;
         for (const [source, cursor] of Object.entries(startCursors)) {
@@ -173,7 +185,7 @@ export class DispatchUsage {
      *
      * So every source in the cursors this process STARTED from that the watcher
      * has not opened yet is reported VERBATIM — the exact `{acked, delivered}`
-     * pair it resumed from — until one write carrying them has landed. That is
+     * pair it resumed from — until a write that carries them has landed. That is
      * what makes "every attach persists its starting cursors" true on the FIRST
      * write rather than one stats tick (15-30 s) later: a reattach of this row
      * inside its first interval reads them back (start-order rule 1) and starts
@@ -289,6 +301,7 @@ export class DispatchUsage {
         return this.queue(async () => {
             if (this.refused)
                 return "refused";
+            this.flushBegan = true;
             const changed = this.counter.takeChanged();
             const batches = chunkEntries(changed);
             const { reports, deliveredAtSend, reportedResets, carriesStartCursors } = this.buildCursorReports();
@@ -360,6 +373,9 @@ export class DispatchUsage {
                         }
                         if (payload.transcriptPath !== undefined)
                             this.transcriptPathSent = true;
+                        // Safe on ANY landed write: `attachCursors` refuses to run after the
+                        // first flush began, so every starting cursor was either carried by
+                        // this write or is superseded by a live one that this write reported.
                         this.startCursorsPersisted = true;
                     }
                 }

package/dist/session-log-watcher.d.ts

@@ -76,7 +76,7 @@ export interface SessionLogWatcherOptions {
      * That lost every line between the last write and the restart; a cursor does
      * not.
      */
-    startCursors?: Record<string, SourceCursorStart>;
+    startCursors: Record<string, SourceCursorStart>;
     /**
      * DX-2954 — rule 4 of the start order: start every ALREADY-EXISTING file at
      * its current end.

package/dist/session-log-watcher.js

@@ -507,7 +507,7 @@ export class SessionLogWatcher {
         this.sessionId = options.sessionId;
         this.dispatchId = options.dispatchId;
         this.pollIntervalMs = options.pollIntervalMs ?? DEFAULT_POLL_INTERVAL_MS;
-        this.startCursors = options.startCursors ?? {};
+        this.startCursors = options.startCursors;
         this.startExistingFilesAtEof = options.startExistingFilesAtEof ?? false;
         this.onCursorPastEof = options.onCursorPastEof;
         this.onSourceDiscovered = options.onSourceDiscovered;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@thehammer/danx-session-telemetry",
-  "version": "0.1.16",
+  "version": "0.1.17",
   "description": "Shared Claude Code transcript collector (DX-2962) — incremental JSONL tailing for the danxbot worker and the danx-dashboard-mcp desktop bridge, so both run identical collector code.",
   "license": "MIT",
   "type": "module",