sidekick-shared 0.27.1 → 0.27.3

package/dist/parsers/subagentStatsCache.js

@@ -0,0 +1,82 @@
+"use strict";
+/**
+ * Memoizes per-transcript subagent stats by file size and mtime.
+ *
+ * Dashboards rescan a session's subagents on a timer, and one parent can own
+ * a hundred subagent transcripts of several MB each. An unchanged transcript
+ * now costs one `stat` instead of a full parse. Callers treat the returned
+ * stats as read-only.
+ *
+ * Node-only: stats files.
+ *
+ * @module parsers/subagentStatsCache
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.cachedSubagentStats = cachedSubagentStats;
+exports.clearSubagentStatsCache = clearSubagentStatsCache;
+const fs = __importStar(require("fs"));
+const MAX_ENTRIES = 1024;
+const cache = new Map();
+/** Stats for one subagent transcript, parsed again only when the file changed. */
+function cachedSubagentStats(filePath, compute) {
+    let stat;
+    try {
+        stat = fs.statSync(filePath);
+    }
+    catch {
+        cache.delete(filePath);
+        return compute();
+    }
+    const hit = cache.get(filePath);
+    if (hit && hit.size === stat.size && hit.mtimeMs === stat.mtimeMs) {
+        cache.delete(filePath);
+        cache.set(filePath, hit);
+        return hit.stats;
+    }
+    const stats = compute();
+    cache.delete(filePath);
+    cache.set(filePath, { size: stat.size, mtimeMs: stat.mtimeMs, stats });
+    if (cache.size > MAX_ENTRIES) {
+        const oldest = cache.keys().next().value;
+        if (oldest !== undefined)
+            cache.delete(oldest);
+    }
+    return stats;
+}
+/** @internal Test hook. */
+function clearSubagentStatsCache() {
+    cache.clear();
+}

package/dist/parsers/subagentTraceParser.js

@@ -52,6 +52,9 @@ const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
 const toolSummary_1 = require("../formatters/toolSummary");
 const noiseClassifier_1 = require("../formatters/noiseClassifier");
+const claudeUsageDedupe_1 = require("../usage/claudeUsageDedupe");
+const subagentUsage_1 = require("../usage/subagentUsage");
+const subagentScanner_1 = require("./subagentScanner");
 // ── Constants ──
 const AGENT_FILE_PATTERN = /^agent-(.+)\.jsonl$/;
 // ── Public API ──
@@ -101,8 +104,8 @@ function parseAgentTrace(filePath, agentId) {
         const toolCalls = [];
         let agentType;
         let description;
-        let inputTokens = 0;
-        let outputTokens = 0;
+        const tokens = { agentId, toolCalls: [], inputTokens: 0, outputTokens: 0 };
+        const usageDeduper = new claudeUsageDedupe_1.ClaudeUsageDeduper();
         let startTime;
         let endTime;
         for (const line of lines) {
@@ -153,11 +156,10 @@ function parseAgentTrace(filePath, agentId) {
                     isHardNoise: hardNoise,
                 });
                 // Extract token usage
-                if (raw.type === 'assistant' && raw.message?.usage) {
-                    const usage = raw.message.usage;
-                    inputTokens += usage.input_tokens || 0;
-                    outputTokens += usage.output_tokens || 0;
-                }
+                // Split lines of one response repeat its usage; count each response once.
+                const usage = (0, claudeUsageDedupe_1.dedupedRawClaudeUsage)(raw, usageDeduper);
+                if (usage)
+                    (0, subagentUsage_1.addUsageToSubagent)(tokens, usage);
                 // Extract tool calls
                 if (raw.type === 'assistant' && Array.isArray(raw.message?.content)) {
                     for (const block of raw.message.content) {
@@ -194,7 +196,10 @@ function parseAgentTrace(filePath, agentId) {
                 // Skip malformed lines
             }
         }
-        if (events.length === 0 && !agentType && !description && inputTokens === 0) {
+        const meta = (0, subagentScanner_1.readAgentMeta)(filePath);
+        agentType = meta.agentType ?? agentType;
+        description = meta.description ?? description;
+        if (events.length === 0 && !agentType && !description && !tokens.totalTokens) {
             return null;
         }
         const durationMs = startTime && endTime ? endTime.getTime() - startTime.getTime() : undefined;
@@ -209,8 +214,12 @@ function parseAgentTrace(filePath, agentId) {
                 agentType,
                 description,
                 toolCalls,
-                inputTokens,
-                outputTokens,
+                inputTokens: tokens.inputTokens,
+                outputTokens: tokens.outputTokens,
+                cacheReadTokens: tokens.cacheReadTokens ?? 0,
+                cacheWriteTokens: tokens.cacheWriteTokens ?? 0,
+                reasoningTokens: tokens.reasoningTokens ?? 0,
+                totalTokens: tokens.totalTokens ?? 0,
                 startTime,
                 endTime,
                 durationMs,

package/dist/promptHistory.d.ts

@@ -8,24 +8,37 @@
  * or somewhere inside one. Every bound stops cleanly and is reported in
  * `boundsHit`; nothing is silently truncated and no bound throws.
  *
+ * Files are streamed in fixed-size chunks and every pass stops at a complete
+ * line, so a large or busy log is read across several calls: the cursor holds
+ * where each file stopped and the next call continues from there. A single
+ * record over `maxRecordBytes` is skipped without being buffered and reported
+ * in `exclusions`, the only way a record is permanently left out.
+ *
  * A prompt can be written before its answer. The cursor then keeps the byte
- * offset of that prompt's line (not its text), the next call replays from it,
- * and the prompt is returned again under the same identity once its first
+ * offset of that prompt's line and its answer-tracking state (never text), and
+ * the prompt is returned again under the same identity once its first
  * answering call brings model or usage (`metadataStatus` says how settled).
  */
 import { type HumanPromptProvider } from './humanPrompt';
 export type PromptHistoryProvider = HumanPromptProvider;
-export type PromptHistoryBound = 'maxSessions' | 'maxFileBytes' | 'maxTotalBytes' | 'deadline' | 'aborted';
+export type PromptHistoryBound = 'maxSessions' | 'maxFileBytes' | 'maxTotalBytes' | 'maxEntries' | 'deadline' | 'aborted';
 export interface PromptHistoryBounds {
     /** Session files read in one call (unchanged files do not count). Default 1000. */
     maxSessions?: number;
     /**
-     * Bytes a single file may need read in this pass. Default 16 MiB. A file over
-     * it is skipped, and calling again with the same bounds skips it again.
+     * Bytes read from one file in one call. Default 16 MiB. A file with more to
+     * read stops at a line boundary and continues on the next call.
      */
     maxFileBytes?: number;
     /** Bytes read across all files in this call. Default 256 MiB. */
     maxTotalBytes?: number;
+    /**
+     * Largest single log record that is parsed. Default 16 MiB. A longer record
+     * is skipped without being buffered and reported in `exclusions`.
+     */
+    maxRecordBytes?: number;
+    /** Entries returned by one call. Default 10 000. */
+    maxEntries?: number;
     /** Wall-clock budget for the call. Default 30 000 ms. */
     deadlineMs?: number;
 }
@@ -39,18 +52,36 @@ export interface PromptHistoryResumeState {
     /** `session_meta` has been seen. */
     meta?: boolean;
 }
+/** Answer metadata gathered so far for an open prompt; never text. */
+export interface PromptHistoryAnswerState {
+    status: 'pending' | 'provisional';
+    /** Claude message id of the first answering call, once one has been seen. */
+    id?: string;
+    model?: string;
+    usage?: PromptHistoryUsage;
+}
 /**
  * The last emitted prompt of a file whose answering call is not final yet.
- * Holds a replay position and a metadata digest, never prompt or answer text.
+ * Holds a position and answer metadata, never prompt or answer text.
  */
 export interface PromptHistoryPendingPrompt {
     ordinal: number;
-    /** Byte offset where the prompt's log line starts; the next pass replays from here. */
+    /** Byte offset where the prompt's log line starts. */
     offset: number;
+    /** Byte length of the prompt's log line, without its newline. */
+    lineBytes?: number;
+    /** Timestamp of the prompt line, used to verify it when it is read again. */
+    timestamp?: string;
     /** Digest of the model, usage, and status last returned for this prompt. */
     emitted: string;
     /** Codex parse state as it was just before the prompt line. */
     state?: PromptHistoryResumeState;
+    /**
+     * Answer tracking to continue from the session offset. Absent only on a
+     * session carried unchanged from a version 2 cursor, which replays from
+     * `offset` the next time it is read.
+     */
+    answer?: PromptHistoryAnswerState;
 }
 export interface PromptHistoryCursorSession {
     provider: PromptHistoryProvider;
@@ -59,19 +90,30 @@ export interface PromptHistoryCursorSession {
     mtimeMs: number;
     /** Ordinal of the last human prompt seen in this file, or -1 when none. */
     lastOrdinal: number;
-    /** Byte offset just past the last complete line processed. */
+    /** Byte offset where the next pass starts reading. */
     offset: number;
     state?: PromptHistoryResumeState;
     pending?: PromptHistoryPendingPrompt;
+    /** A bound stopped the last pass before the end of the file. */
+    backlog?: true;
+    /** `offset` is inside a record over `maxRecordBytes`; skip to its newline. */
+    skipping?: true;
+    /** Digest of the file's first bytes, used to detect a rewritten file. */
+    head?: {
+        bytes: number;
+        hash: string;
+    };
 }
 /**
  * JSON-serializable resume point. Keys are opaque and never contain paths, but
  * values can (Codex `state.cwd`), so treat the cursor as sensitive local state.
- * Version 1 cursors from 0.27.0 are accepted as input; output is always version 2.
+ * Version 1 and 2 cursors are accepted as input; output is always version 3.
  */
 export interface PromptHistoryCursor {
-    version: 2;
+    version: 3;
     sessions: Record<string, PromptHistoryCursorSession>;
+    /** Opaque key of the file the next call starts with, after a call-wide stop. */
+    next?: string;
 }
 /**
  * How settled an entry's `model` / `usage` are:
@@ -112,14 +154,35 @@ export interface PromptHistoryEntry {
      */
     metadataStatus: PromptHistoryMetadataStatus;
 }
+/**
+ * A log record permanently left out. Records over `maxRecordBytes` and lines
+ * that are not valid JSON are never parsed, so any prompt inside is lost, and
+ * the ordinals of later prompts in that file do not count it.
+ */
+export interface PromptHistoryExclusion {
+    provider: PromptHistoryProvider;
+    sessionId: string;
+    reason: 'oversizedRecord' | 'malformedRecord';
+    /** Byte offset where the record starts. */
+    offset: number;
+}
 export interface PromptHistoryStats {
     sessionsScanned: number;
     sessionsSkippedUnchanged: number;
     /** Scanned sessions with human prompts but none inside the allowed roots. */
     sessionsOutOfScope: number;
+    /** Files whose `maxFileBytes` budget ran out; they continue on the next call. */
     filesOverSizeLimit: number;
+    /** Scanned sessions left with unread bytes by any bound; they continue next call. */
+    sessionsWithBacklog: number;
+    /** Sessions whose file was truncated or rewritten and was read again from the start. */
+    sessionsRewritten: number;
     /** Codex sessions skipped as non-interactive (subagent, fork, unknown source). */
     sessionsNotInteractive: number;
+    /** Records skipped for exceeding `maxRecordBytes` (see `exclusions`). */
+    recordsOverSizeLimit: number;
+    /** Complete lines that were not valid JSON (see `exclusions`). */
+    recordsMalformed: number;
     /** Human prompts dropped because the log line had no usable timestamp. */
     promptsMissingTimestamp: number;
     /** Human prompts dropped because their cwd was missing or outside the roots. */
@@ -143,7 +206,16 @@ export interface PromptHistoryResult {
     entries: PromptHistoryEntry[];
     cursor: PromptHistoryCursor;
     stats: PromptHistoryStats;
+    /** Resumable stops: calling again with the returned cursor continues past them. */
     boundsHit: PromptHistoryBound[];
+    /** Permanent exclusions found in this call (at most 1000; stats count all). */
+    exclusions: PromptHistoryExclusion[];
+    /** A bound left bytes or files unread; call again with the cursor to continue. */
+    hasMore: boolean;
 }
+/** Test hooks; not part of the public entry points. */
+export declare const __promptHistoryTesting: {
+    setReadChunkBytes(bytes: number | null): void;
+};
 /** Collect human-typed prompts from Claude Code and Codex logs under the given roots. */
 export declare function collectPromptHistory(options: CollectPromptHistoryOptions): Promise<PromptHistoryResult>;