watchmyagents 1.4.3 → 1.4.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "watchmyagents",
-  "version": "1.4.3",
+  "version": "1.4.4",
   "description": "Security observability + real-time policy enforcement for AI agents. Local-first NDJSON capture with a continuous Watch daemon that auto-uploads anonymized signals, Shield CLI that blocks policy violations live (with policies pulled from Fortress cloud), anonymizer producing signals-only payloads, bidirectional sync with WatchMyAgents Fortress, and one-command install as an always-on launchd/systemd service — closing the recursive Watch→Guardian→Shield security loop.",
   "type": "module",
   "files": [

package/scripts/fetch-anthropic.js

@@ -383,17 +383,25 @@ async function runWatch({ apiKey, resolveAgents, fleet, logDir, intervalMs, wind
   let agents = await resolveAgents();
   // v1.4.3 F-51: bounded dedup. Preloaded on-disk ids are static; runtime ids
   // are tracked per-session and dropped on terminate (see src/watch-state.js).
-  const preloaded = [];
-  for (const ag of agents) {
-    for (const id of await preloadSeenIds(logDir, ag.agentId)) preloaded.push(id);
+  const seen = new SeenTracker();
+  // v1.4.4 F-53: preload each agent's on-disk history the FIRST time we see it
+  // — including agents that --all-agents discovers after startup. Pre-fix the
+  // preload ran once for the initial fleet only, so a late-appearing agent with
+  // existing logs re-appended + re-uploaded already-captured events.
+  const preloadedAgents = new Set();
+  async function ensurePreloaded(agentId) {
+    if (preloadedAgents.has(agentId)) return;
+    preloadedAgents.add(agentId);
+    for (const id of await preloadSeenIds(logDir, agentId)) seen.addPreloaded(id);
   }
-  const seen = new SeenTracker(preloaded);
+  for (const ag of agents) await ensurePreloaded(ag.agentId);
   const loggers = new Map();     // sessionId → Logger (session ids are globally unique)
-  const ended = new Set();       // terminated sessions (skip). Grows one id per
-                                  // terminated session over the daemon's life —
-                                  // bounded by session COUNT (ids only, the
-                                  // smallest term); the per-EVENT growth that
-                                  // actually drove OOM is fixed via SeenTracker.
+  // terminated sessions (skip). v1.4.4 F-54: a Map<sid → terminatedAtMs> so we
+  // can TTL-prune. A session terminated more than windowMs ago has created_at
+  // older still, so listSessions (which filters created_at < since, since =
+  // now - windowMs) can no longer return it — its id is then safe to forget,
+  // bounding this map's growth on a long daemon with many short sessions.
+  const ended = new Map();
   const sessionAgent = new Map();// sessionId → { agentId, model, displayName }
   const priors = new Map();      // agentId → previous classification (threads the
                                   // typology state machine across upload cycles)
@@ -413,9 +421,20 @@ async function runWatch({ apiKey, resolveAgents, fleet, logDir, intervalMs, wind
     if (fleet) { const next = await resolveAgents(); if (next.length) agents = next; }
     const since = new Date(Date.now() - windowMs);
 
+    // F-54: forget sessions terminated longer ago than the discovery window —
+    // listSessions can no longer surface them (created_at < since), so their
+    // skip-marker is no longer needed. Bounds `ended` on a long-running daemon.
+    const ttlCutoff = Date.now() - windowMs;
+    for (const [sid, terminatedAt] of ended) {
+      if (terminatedAt < ttlCutoff) ended.delete(sid);
+    }
+
     // (1) Discover sessions in the window; register the owning agent for each.
     for (const ag of agents) {
       if (ac.signal.aborted) break;
+      // F-53: a late-discovered agent (fleet mode) gets its disk history
+      // preloaded before we fetch any of its sessions, so dedup holds.
+      await ensurePreloaded(ag.agentId);
       const tag = fleet ? `[${ag.displayName}] ` : '';
       let sessions = [];
       try { sessions = await listSessions(apiKey, { agentId: ag.agentId, since }); }
@@ -507,7 +526,7 @@ async function runWatch({ apiKey, resolveAgents, fleet, logDir, intervalMs, wind
           session_tokens: { input: stats.input, output: stats.output, cache_read: stats.cache_read, cache_creation: stats.cache_creation, total: stats.sum },
           session_cost_usd: stats.cost_usd || null,
         });
-        ended.add(sid);
+        ended.set(sid, Date.now());
         // v1.4.3 F-51: bound memory — terminated sessions aren't re-fetched,
         // so drop their per-session dedup set AND their Logger object (the
         // latter was never deleted pre-fix → unbounded growth of Logger

package/src/sources/anthropic-managed.js

@@ -265,6 +265,18 @@ export async function* transformRawEventsToWMAActions(rawEventsAsyncIterable, {
   // distinct API-level IDs will populate parent_agent_id natively.
   const subThreadIds = new Set();
 
+  // v1.4.4 F-52 (P2 audit): only emit the end-of-stream "no_result_observed"
+  // flush when the session ACTUALLY terminated in this stream. In watch mode
+  // fetchRawEvents re-fetches the FULL session every cycle, so a tool whose
+  // start lands in cycle N but whose result lands in cycle N+1 would, with an
+  // unconditional flush, get a phantom no_result_observed row (id = start id)
+  // in cycle N AND the real paired row (id = result id) in cycle N+1 — a
+  // double-count + persistent phantom error skewing error_rate_by_tool. While
+  // the session is still running an unpaired start is in-flight, not
+  // "no result observed"; it stays pending and pairs (or flushes) once the
+  // session's terminal state is observed.
+  let sessionTerminated = false;
+
   // `provider` is the canonical field per src/sources/contract.js (no
   // other consumer ever read the previous `framework` field, so it was
   // dropped in PR-B with zero downstream impact).
@@ -632,6 +644,8 @@ export async function* transformRawEventsToWMAActions(rawEventsAsyncIterable, {
       const prefix = isThread ? 'session.thread_status_' : 'session.status_';
       const state = type.slice(prefix.length); // 'running' | 'idle' | 'rescheduled' | 'terminated'
       const fatal = state === 'terminated';
+      // F-52: a SESSION-scope terminate (not a sub-thread one) gates the flush.
+      if (fatal && !isThread) sessionTerminated = true;
       yield {
         ...base,
         ...subAgentMeta,
@@ -666,6 +680,16 @@ export async function* transformRawEventsToWMAActions(rawEventsAsyncIterable, {
   // explicitly with status='error' keeps the local NDJSON, anonymizer
   // signals (counts, IoC hashes, tool_counts), and Fortress decisions
   // honest about what actually happened.
+  //
+  // v1.4.4 F-52: GATED on sessionTerminated. If the session is still running
+  // (watch mode re-fetches the full session every cycle), an unpaired start is
+  // in-flight, not lost — flushing it now would create a phantom row that the
+  // next cycle's real paired row double-counts. We only flush once the
+  // session's terminal state proves the calls genuinely never resolved. (Both
+  // F-8 and F-50 flush tests feed a session.status_terminated event, so this
+  // gate is satisfied for them.)
+  if (!sessionTerminated) return;
+
   for (const [toolUseId, pending] of pendingToolUse) {
     yield {
       ...base,

package/src/watch-state.js

@@ -24,6 +24,15 @@ export class SeenTracker {
     this._bySession = new Map();   // sessionId -> Set<eventId>
   }
 
+  // v1.4.4 F-53: fold an agent's on-disk history into the static preloaded
+  // set. Called lazily the first time an agent is seen (including agents that
+  // --all-agents discovers AFTER startup) so their already-captured NDJSON ids
+  // are deduped against — otherwise a late-appearing agent with existing logs
+  // would re-append and re-upload events it already has.
+  addPreloaded(id) {
+    if (id) this._preloaded.add(id);
+  }
+
   has(sessionId, eventId) {
     if (this._preloaded.has(eventId)) return true;
     const s = this._bySession.get(sessionId);