@newrelic/preflight 1.50.7 → 1.50.9

package/dist/index.js

@@ -1082,6 +1082,10 @@ async function main() {
             getRecords: () => toolCallBuffer,
         };
         sessionStore = new SessionStore({ storagePath: config.storagePath });
+        // Non-null capture so the aggregator's callback (invoked lazily, long
+        // after this point) doesn't have to re-narrow `sessionStore: SessionStore
+        // | undefined` — same pattern as sessionStoreForCostBaseline below.
+        const sessionStoreForAggregator = sessionStore;
         const currentSessionId = sessionTracker.getMetrics().sessionId;
         let currentRepoName = null;
         // An unscoped process (--local, or a provisional --stdio window) drains
@@ -1089,7 +1093,13 @@ async function main() {
         // synthetic id, which persistSession() skips — so without this rollup the
         // sessions it observes are never written to disk at all. See
         // local-session-aggregator.ts for why that hits Copilot but not Claude Code.
-        const localSessionAggregator = new LocalSessionAggregator();
+        const localSessionAggregator = new LocalSessionAggregator({
+            // Restart survival: the first subagent turn this process sees for a
+            // session folds in whatever that session's file already says (a
+            // --stdio engine's final write, or this daemon's own last checkpoint)
+            // before adding the tail — see applyPersistedBaseline's doc comment.
+            persistedCostBaseline: (id) => sessionStoreForAggregator.loadSession(id),
+        });
         const repoNameResolver = new RepoNameResolver();
         const budgetTracker = new BudgetTracker({
             sessionBudgetUsd: config.sessionBudgetUsd,
@@ -1571,22 +1581,12 @@ async function main() {
                     observabilityHealth: {
                         getSnapshot: () => {
                             // Read live counters off the SubagentWatcher when it's running.
-                            // A null binding => watcher disabled (env flag off / wrong mode)
-                            // => a zeroed "disabled" snapshot. costSelfCheckDeltaPct stays
-                            // null until the 1h self-check is wired.
+                            // A null binding => watcher disabled (env flag off) => a zeroed
+                            // "disabled" snapshot. costSelfCheckDeltaPct stays null until
+                            // the 1h self-check is wired.
                             const stats = activeSubagentWatcher?.getHealthStats();
                             const watcherActive = activeSubagentWatcher !== null;
-                            // Re-derive which of the two independent conditions caused a
-                            // null binding, rather than reading the `subagentWatcherEnabled`/
-                            // `watcherShouldRun` consts from the outer closure — this way
-                            // the reason is always self-consistent with the actual env var
-                            // at snapshot time, with no scope-ordering dependency on where
-                            // those consts are declared in this large startup function.
-                            const watcherDisabledReason = watcherActive
-                                ? null
-                                : process.env['NR_AI_ENABLE_SUBAGENT_WATCHER'] === '0'
-                                    ? 'env_var'
-                                    : 'mode_mismatch';
+                            const watcherDisabledReason = watcherActive ? null : 'env_var';
                             return {
                                 watcherActive,
                                 filesWatched: stats?.filesWatched ?? 0,
@@ -2112,6 +2112,22 @@ async function main() {
                 // belong in the model breakdown too — recording them only in the cost
                 // tracker left Model Usage blind to every subagent-only session.
                 modelUsageTracker.recordUsage(turn.model, usage, breakdown.totalUsd);
+                // The only line that makes an orphan session's subagent spend durable:
+                // without it, an unscoped process's aggregator never learns about this
+                // session's subagent cost and persistSession() has nothing to write.
+                // `agentId` is the same discriminator costTracker.recordTokenUsage
+                // splits parent-vs-subagent on above, so the two trackers can't drift.
+                localSessionAggregator.recordTokenUsage(turn.parentSessionId, {
+                    timestamp: turn.timestampMs,
+                    costUsd: breakdown.totalUsd,
+                    model: turn.model,
+                    inputTokens: turn.inputTokens,
+                    outputTokens: turn.outputTokens,
+                    cacheReadTokens: turn.cacheReadTokens,
+                    cacheCreationTokens: turn.cacheCreationTokens,
+                    thinkingTokens: turn.reasoningTokens,
+                    agentId: turn.agentId,
+                });
                 // Pricing miss → usd:null on the wire; we recompute here so
                 // the breakdown view distinguishes "0 because pricing absent" from
                 // "0 because the turn truly had zero cost".
@@ -2326,13 +2342,7 @@ async function main() {
             }
         }, SESSION_PERSIST_INTERVAL_MS);
         sessionPersistInterval.unref?.();
-        // Single-mode rule: the watcher runs in `--stdio` mode by default.
-        // Opt-in to watcher-in-dashboard via `NR_AI_WATCHER_MODE=local`.
-        const watcherMode = (process.env['NR_AI_WATCHER_MODE'] ?? 'stdio').toLowerCase();
         const isStdioWatcher = options.stdio === true;
-        const isLocalWatcher = !isStdioWatcher;
-        const watcherShouldRun = (isStdioWatcher && (watcherMode === 'stdio' || watcherMode === '')) ||
-            (isLocalWatcher && watcherMode === 'local');
         // The SubagentWatcher is the ONLY thing that feeds per-agent (subagent)
         // token cost into the CostTracker (via onSubagentTurn → subagentCostUsd).
         // With it off, a session's persisted/headline cost silently excludes ALL
@@ -2343,13 +2353,18 @@ async function main() {
         // (parentSessionId filter), so it only ever attributes that session's own
         // subagents — parent tokens (onTokenEvent, parent transcript) and subagent
         // tokens (onSubagentTurn, subagent transcripts) are disjoint, so there is no
-        // double count. The WorkflowWatcher stays opt-in (NR_AI_ENABLE_WORKFLOW_WATCHER=1).
+        // double count. Unfiltered (`--local`), the heartbeat exclusion
+        // (subagent-watcher.ts's discoverFiles) is what keeps it from racing a live
+        // `--stdio` session's own scoped watcher over the same cursor files — see
+        // that module's doc comment. The WorkflowWatcher stays engine-only: it has
+        // no heartbeat exclusion, so running it unfiltered would reintroduce that
+        // exact race for workflow transcripts.
         const subagentWatcherEnabled = process.env['NR_AI_ENABLE_SUBAGENT_WATCHER'] !== '0';
         const workflowWatcherEnabled = process.env['NR_AI_ENABLE_WORKFLOW_WATCHER'] === '1';
-        // Unlike subagent/workflow watchers, ParentTranscriptWatcher is NOT gated
-        // by watcherShouldRun/NR_AI_WATCHER_MODE — see startWatchers() below for
-        // why. Do not "fix" this to match the other two; that would reintroduce
-        // the exact regression this divergence avoids.
+        // Unlike WorkflowWatcher, ParentTranscriptWatcher is not gated
+        // by --stdio-vs-`--local` at all — see startWatchers() below for why. Do
+        // not "fix" this to match WorkflowWatcher; that would reintroduce the exact
+        // regression this divergence avoids.
         const parentTranscriptWatcherEnabled = process.env['NR_AI_ENABLE_PARENT_TRANSCRIPT_WATCHER'] !== '0';
         // CopilotUsageWatcher is the Copilot analog of ParentTranscriptWatcher
         // (token-exact cost from VS Code's Copilot debug logs) and follows the
@@ -2375,15 +2390,14 @@ async function main() {
             // ParentTranscriptWatcher feeds parent-session token/cost tracking —
             // the primary cost signal, not a secondary one like subagent/workflow
             // cost. The old per-hook transcript scanner it replaces ran
-            // unconditionally in every mode with zero coupling to
-            // NR_AI_WATCHER_MODE; gating this behind watcherShouldRun the same way
-            // SubagentWatcher/WorkflowWatcher are gated would mean a standalone
-            // `--local` deployment (no --stdio sibling, NR_AI_WATCHER_MODE unset)
-            // goes from "buggy but nonzero" parent-cost tracking to "exactly zero"
-            // by default — a real regression. So it always runs, gated only by its
-            // own opt-out flag. Race-safety for "--stdio and --local both alive for
-            // the same session" comes for free from the same
-            // getActiveSessionIdsFromHeartbeats() exclusion SubagentWatcher's
+            // unconditionally in every mode with zero coupling to --stdio-vs-`--local`;
+            // gating this behind isStdioWatcher the same way WorkflowWatcher is
+            // gated would mean a standalone `--local` deployment (no --stdio
+            // sibling) goes from "buggy but nonzero" parent-cost tracking to
+            // "exactly zero" by default — a real regression. So it always runs,
+            // gated only by its own opt-out flag. Race-safety for "--stdio and
+            // --local both alive for the same session" comes for free from the
+            // same getActiveSessionIdsFromHeartbeats() exclusion SubagentWatcher's
             // unscoped discovery already uses.
             if (parentTranscriptWatcherEnabled) {
                 activeParentTranscriptWatcher = new ParentTranscriptWatcher({
@@ -2418,50 +2432,68 @@ async function main() {
                     parentSessionId: isStdioWatcher ? watcherSessionId : null,
                 });
             }
-            if (watcherShouldRun && subagentWatcherEnabled) {
-                activeSubagentWatcher = new SubagentWatcher({
+            if (subagentWatcherEnabled) {
+                // Base options are mode-independent. The scoped extras are a single
+                // ternary branch, not two independent fields, because the options
+                // type makes `costSelfCheck` without `parentSessionId` a compile
+                // error: the self-check compares this process's whole-tracker
+                // subagent total against a re-parse of ONE session, and those are
+                // the same population only while the watcher is filtered to that
+                // session.
+                const subagentWatcherBase = {
                     storagePath: config.storagePath,
-                    parentSessionId: isStdioWatcher ? watcherSessionId : undefined,
                     // Only meaningful when unfiltered (--local) — lets discoverFiles()
                     // skip sessions that already have a live --stdio owner tailing them.
                     localStore,
-                    // Runtime cost-self-check: a drift > 5% surfaces as an
-                    // `AiObservabilityHealth { event: 'cost_self_check' }` event. We
-                    // compare like-with-like from two INDEPENDENT code paths so a
-                    // regression in either is caught:
-                    //   - trackedUsd: subagent cost the live CostTracker accumulated from
-                    //     the onSubagentTurn feed (the headline/persisted path), and
-                    //   - groundTruthUsd: an independent re-parse of the same session's
-                    //     subagent transcripts via SubagentTimelineStore (the trace path).
-                    // Both dedup streaming-duplicate lines by message.id, so a healthy
-                    // system reads ~0%; any divergence (e.g. one path regressing on dedup
-                    // or pricing) shows up as a real, non-zero delta. Only meaningful in
-                    // --stdio mode, where the watcher is scoped to this one session.
-                    costSelfCheck: () => {
-                        const trackedUsd = costTracker.getSubagentMetrics().subagentUsd;
-                        let groundTruthUsd = trackedUsd;
-                        try {
-                            const tl = subagentTimelineInstance.getSubagentsForSession(watcherSessionId);
-                            groundTruthUsd = tl.agents.reduce((sum, a) => sum + (a.usd ?? 0), 0);
-                        }
-                        catch {
-                            // On any re-parse error fall back to trackedUsd → 0% delta (no
-                            // false alarm); the error is already surfaced via watcher health.
-                            groundTruthUsd = trackedUsd;
-                        }
-                        return { trackedUsd, groundTruthUsd };
-                    },
-                });
+                };
+                activeSubagentWatcher = new SubagentWatcher(isStdioWatcher
+                    ? {
+                        ...subagentWatcherBase,
+                        parentSessionId: watcherSessionId,
+                        // Runtime cost-self-check: a drift > 5% surfaces as an
+                        // `AiObservabilityHealth { event: 'cost_self_check' }` event.
+                        // We compare like-with-like from two INDEPENDENT code paths
+                        // so a regression in either is caught:
+                        //   - trackedUsd: subagent cost the live CostTracker
+                        //     accumulated from the onSubagentTurn feed (the
+                        //     headline/persisted path), and
+                        //   - groundTruthUsd: an independent re-parse of the same
+                        //     session's subagent transcripts via SubagentTimelineStore
+                        //     (the trace path).
+                        // Both dedup streaming-duplicate lines by message.id, so a
+                        // healthy system reads ~0%; any divergence (e.g. one path
+                        // regressing on dedup or pricing) shows up as a real, non-zero
+                        // delta. Only meaningful in --stdio mode, where the watcher is
+                        // scoped to this one session.
+                        costSelfCheck: () => {
+                            const trackedUsd = costTracker.getSubagentMetrics().subagentUsd;
+                            let groundTruthUsd = trackedUsd;
+                            try {
+                                const tl = subagentTimelineInstance.getSubagentsForSession(watcherSessionId);
+                                groundTruthUsd = tl.agents.reduce((sum, a) => sum + (a.usd ?? 0), 0);
+                            }
+                            catch {
+                                // On any re-parse error fall back to trackedUsd → 0% delta
+                                // (no false alarm); the error is already surfaced via
+                                // watcher health.
+                                groundTruthUsd = trackedUsd;
+                            }
+                            return { trackedUsd, groundTruthUsd };
+                        },
+                    }
+                    : subagentWatcherBase);
                 activeSubagentWatcher.start();
                 logger.info('SubagentWatcher started', {
-                    mode: watcherMode,
                     parentSessionId: isStdioWatcher ? watcherSessionId : null,
                 });
             }
-            if (watcherShouldRun && workflowWatcherEnabled) {
+            // Engine-only: unlike SubagentWatcher, WorkflowWatcher has no heartbeat
+            // exclusion, so running it unfiltered in --local would reintroduce the
+            // same race for workflow transcripts.
+            if (isStdioWatcher && workflowWatcherEnabled) {
                 activeWorkflowWatcher = new WorkflowWatcher({
                     storagePath: config.storagePath,
-                    parentSessionId: isStdioWatcher ? watcherSessionId : undefined,
+                    parentSessionId: watcherSessionId,
                     getCostForRun: (runId) => costTracker.getCostForWorkflowRun(runId),
                 });
                 activeWorkflowWatcher.setOnRun((run) => {
@@ -2471,10 +2503,7 @@ async function main() {
                     capturedNrIngest?.ingestObservabilityHealth(health);
                 });
                 activeWorkflowWatcher.start();
-                logger.info('WorkflowWatcher started', {
-                    mode: watcherMode,
-                    parentSessionId: isStdioWatcher ? watcherSessionId : null,
-                });
+                logger.info('WorkflowWatcher started', { parentSessionId: watcherSessionId });
             }
         };
         // Re-point the watchers from a provisional `pending-<ts>` session id to the