sidekick-shared 0.29.0 → 0.30.0

package/dist/esm/aggregation/snapshot.js

@@ -2,14 +2,18 @@
  * Session snapshot sidecar — persists aggregator state + reader position
  * so that re-attaching to a session skips full replay.
  *
- * Snapshots are stored in ~/.config/sidekick/snapshots/{sessionId}.json.
- * They are invalidated when the source file changes beyond the snapshot position.
+ * Snapshots are stored in `<config dir>/snapshots/{sessionId}.json` (see
+ * `getConfigDir()`). They are invalidated when the source file shrank below
+ * the snapshot position or, for file-backed sessions that recorded a
+ * {@link SessionSnapshot.sourceCheckpoint}, when the file is no longer the
+ * same append-only file.
  *
  * @module aggregation/snapshot
  */
 import * as fs from 'fs';
 import * as path from 'path';
 import { getConfigDir } from '../paths';
+import { verifyJsonlCheckpoint } from '../watchers/jsonlTail';
 import { atomicWriteJsonSync } from '../writers/atomic';
 import { SNAPSHOT_SCHEMA_VERSION } from './EventAggregator';
 /** Current schema version — bump when format changes. */
@@ -101,8 +105,8 @@ export function pruneSnapshots(keep = MAX_SNAPSHOT_FILES) {
  * - Schema version doesn't match
  * - JSON parse fails
  *
- * The caller is responsible for staleness checks (comparing sourceSize
- * and readerPosition against the actual file).
+ * The caller is responsible for staleness checks against the actual file:
+ * `isSnapshotValid(snapshot, currentSize, sourcePath)`.
  */
 export function loadSnapshot(sessionId) {
     try {
@@ -142,13 +146,21 @@ export function deleteSnapshot(sessionId) {
 /**
  * Validates whether a snapshot is still usable for a given source file.
  *
- * For JSONL providers: checks that the file hasn't been truncated
- * (current size >= snapshot position) and that the size matches or has grown.
- *
  * For DB-backed providers: sourceSize is 0, so we always consider valid
  * (the DB reader's timestamp-based cursor handles staleness naturally).
+ *
+ * For JSONL providers: the file must not have shrunk below the snapshot
+ * position. With `sourcePath` the check is also content-aware: the snapshot
+ * must carry a {@link SessionSnapshot.sourceCheckpoint} for exactly
+ * `readerPosition`, and that checkpoint must still match the file at
+ * `sourcePath` (same device and inode, same first bytes, position just after
+ * a newline), so a file replaced by another one or rewritten to the same or
+ * a larger size is not resumed mid-content. A snapshot without a checkpoint
+ * (written before 0.29.1) is invalid when `sourcePath` is given, which costs
+ * one full replay. Without `sourcePath` only the size check applies, as it
+ * did before.
  */
-export function isSnapshotValid(snapshot, currentSourceSize) {
+export function isSnapshotValid(snapshot, currentSourceSize, sourcePath) {
     // DB-backed providers store sourceSize=0 — always valid (cursor is a timestamp)
     if (snapshot.sourceSize === 0) {
         return true;
@@ -157,5 +169,15 @@ export function isSnapshotValid(snapshot, currentSourceSize) {
     if (currentSourceSize < snapshot.readerPosition) {
         return false;
     }
-    return true;
+    if (typeof sourcePath !== 'string') {
+        return true;
+    }
+    // Snapshot content comes from disk: guard the shape before trusting it.
+    const checkpoint = snapshot.sourceCheckpoint;
+    if (!checkpoint ||
+        typeof checkpoint !== 'object' ||
+        checkpoint.offset !== snapshot.readerPosition) {
+        return false;
+    }
+    return verifyJsonlCheckpoint(sourcePath, checkpoint);
 }

package/dist/esm/browser.js

@@ -17,6 +17,8 @@ export { addLocalDays, formatDurationMs, formatLocalDateKey, formatTokenCount, p
 export { parseMcpToolName } from './parsers/mcpToolName';
 export { buildSessionContextSnapshot, calculateSessionContextPressure, createSessionContextProjector, } from './context/sessionContext';
 export { ACCOUNT_PROVIDER_IDS, MODEL_PROVIDER_IDS, QUOTA_PROVIDER_IDS, RUNTIME_QUOTA_PROVIDER_IDS, SESSION_PROVIDER_IDS, } from './providerIds';
+export { SUBAGENT_SPAWN_TOOL_NAMES, agentsStoppedNoticeFromEvent, isAgentsKilledSystemEvent, isCodexSubagentSpawnTool, isSubagentSpawnTool, isTaskNotificationSystemEvent, isTaskStatusSystemEvent, parseAgentsStoppedNotice, parseCodexSpawnLaunch, parseTaskNotification, taskNotificationFromEvent, taskStatusFromAttachment, taskStatusFromEvent, } from './subagentSpawn';
+export { SUBAGENT_PARENT_IDLE_ENDED_MS, SUBAGENT_UNREPORTED_QUIET_MS, resolveSubagentDisplayState, subagentDisplayLabel, } from './subagentDisplayState';
 export { assistantTurnEventsFromSessionEvents, extractTurnSubagents, isAssistantTurnSubagentTool, reasoningSummary, segmentAssistantTurn, } from './turns/assistantTurn';
 export { parseModelId, getModelPricing, resolveModelPricing, getModelInfo, calculateCost, calculateCostWithPricing, calculateCostWithProvenance, mergeCostSources, shortModelName, getModelDisplayInfo, compareModelIds, sortModelIds, formatCost, canonicalModelId, isMovingModelAlias, registerModelPricing, clearRegisteredModelPricing, getPricingCatalogInfo, costSourceFromPricingProvenance, mergeCostComponents, } from './modelInfo';
 export { exportResolvedModelCatalog, importResolvedModelCatalog, registerModelAlias, resolveModelAlias, RESOLVED_MODEL_CATALOG_SCHEMA_VERSION, } from './modelCatalog';
@@ -30,6 +32,7 @@ export { isAggregateCodexLimit } from './types/codex';
 // Codex rollout parsing (pure: no filesystem access)
 export { CodexRolloutParser, DEFAULT_MAX_TRACKED_TOOL_CALLS, extractPatchFilePaths, normalizeCodexToolName, normalizeCodexToolInput, resolveCodexCallUsage, } from './parsers/codexParser';
 export { codexRolloutOrigin, codexSpawnParentFromSource } from './parsers/codexRolloutOrigin';
+export { SUBAGENT_ACTIVITY_BLOCK_TYPE, SUBAGENT_ACTIVITY_ORIGIN_KIND, describeSubagentActivity, isSubagentActivitySystemEvent, parseCodexAgentMessageText, subagentActivityFromEvent, } from './subagentActivity';
 export { HUMAN_CLAUDE_ENTRYPOINTS, HUMAN_CODEX_SOURCES, humanPromptText, isHumanPrompt, } from './humanPrompt';
 export { renderHandoffUrlTemplate } from './handoffUrl';
 // Tool categories across providers

package/dist/esm/context/sessionContext.js

@@ -8,6 +8,8 @@ import { EventAggregator } from '../aggregation/EventAggregator';
 import { getModelContextWindowSize } from '../modelContext';
 import { parseMcpToolName } from '../parsers/mcpToolName';
 import { estimateTextTokens } from '../tokenEstimation';
+import { isTaskNotificationSystemEvent, isTaskStatusSystemEvent } from '../subagentSpawn';
+import { isSubagentActivitySystemEvent } from '../subagentActivity';
 const DEFAULT_CONTEXT_SOURCE_LIMIT = 200;
 const DEFAULT_SNIPPET_MAX_CHARS = 240;
 const DEFAULT_BODY_MAX_CHARS = 5000;
@@ -205,6 +207,12 @@ function extractSourcesFromEvent(event, state) {
     }
 }
 function extractSystemSource(event, state) {
+    // Background-task notices only update subagent lifecycles (like the aggregator).
+    if (isTaskNotificationSystemEvent(event) || isTaskStatusSystemEvent(event))
+        return;
+    // So are subagent lifecycle records (opt-in Codex parser events).
+    if (isSubagentActivitySystemEvent(event))
+        return;
     const message = event.message;
     const text = extractText(message?.content);
     const label = message?.sourceLabel ?? message?.role ?? 'system';

package/dist/esm/fileContinuity.js

@@ -0,0 +1,149 @@
+/**
+ * Continuity of a file read incrementally by byte offset: whether the file
+ * now at a path is still the content earlier reads consumed, or was
+ * truncated, rewritten, or replaced since.
+ *
+ * {@link FileContinuity} holds the rules `createJsonlTail` applies, so every
+ * incremental reader detects the same cases the same way:
+ *
+ * - `replaced`: another file (by device and inode, read from the open
+ *   descriptor, so a rename between a stat and an open cannot mix two files)
+ *   now has the path.
+ * - `truncated`: the file is shorter than the read position.
+ * - `rewritten`: the mtime changed and either the first {@link HEAD_BYTES}
+ *   bytes differ from those recorded, or the byte before the committed
+ *   (resume-safe) offset is no longer a newline.
+ *
+ * Replacement and truncation are checked on every read; the content probe
+ * only when the mtime changed or the recorded head is still short.
+ *
+ * Known limits: a rewrite that leaves the mtime unchanged (coarse mtime
+ * resolution, or an mtime restored on purpose) or that changes only bytes
+ * past the first 4 KiB while the resume point still follows a newline goes
+ * unnoticed; on filesystems without stable inode numbers (some SMB mounts,
+ * Windows) an unchanged file can read as replaced, which costs a replay.
+ *
+ * @module fileContinuity
+ */
+import * as fs from 'fs';
+import { fileHeadOf, HEAD_BYTES, headMatches } from './fileHead';
+/**
+ * What one reader knows about the file its offsets refer to: identity,
+ * mtime, and a digest of the first bytes, recorded by {@link adopt} after
+ * each read.
+ *
+ * Synchronous readers call {@link check} on the open descriptor, restart
+ * from offset 0 when it returns a reason, then call {@link adopt}. A reader
+ * that repositions without reading (a seek to a stored offset, a reset)
+ * calls {@link forget}, so its next read adopts the file instead of
+ * comparing it with the old one. The lower-level methods ({@link needsProbe},
+ * {@link reasonFor}, {@link record}) serve asynchronous readers that probe
+ * on their own.
+ */
+export class FileContinuity {
+    identity = null;
+    head = null;
+    lastMtimeMs = -1;
+    /** What the last {@link check} probed and decided, for {@link adopt}. */
+    checked = null;
+    /** Device and inode of the adopted file; `null` before the first read and after {@link forget}. */
+    get knownIdentity() {
+        return this.identity;
+    }
+    /** Length and digest of the adopted file's first bytes, once probed. */
+    get knownHead() {
+        return this.head;
+    }
+    /** Whether {@link reasonFor} needs bytes from the file to decide. */
+    needsProbe(stat, readOffset) {
+        return (this.identity === null ||
+            stat.dev !== this.identity.dev ||
+            stat.ino !== this.identity.ino ||
+            stat.size < readOffset ||
+            stat.mtimeMs !== this.lastMtimeMs ||
+            this.head === null ||
+            this.head.bytes < Math.min(HEAD_BYTES, stat.size));
+    }
+    /**
+     * Why the reader must start over: the path now names another file, the
+     * file shrank below `readOffset`, its first bytes changed, or the resume
+     * point no longer follows a newline. `null` when it can continue.
+     */
+    reasonFor(stat, readOffset, probe) {
+        if (this.identity && (stat.dev !== this.identity.dev || stat.ino !== this.identity.ino)) {
+            return 'replaced';
+        }
+        if (stat.size < readOffset)
+            return 'truncated';
+        if (this.identity && stat.mtimeMs !== this.lastMtimeMs && probe) {
+            if (this.head && !headMatches(this.head, probe.prefix))
+                return 'rewritten';
+            if (probe.before && probe.before[0] !== 0x0a)
+                return 'rewritten';
+        }
+        return null;
+    }
+    /** Records the identity, mtime, and (from `probe`) first bytes of the file the offsets now refer to. */
+    record(stat, probe) {
+        this.identity = { dev: stat.dev, ino: stat.ino };
+        this.lastMtimeMs = stat.mtimeMs;
+        if (probe && (!this.head || this.head.bytes < Math.min(HEAD_BYTES, stat.size))) {
+            this.head = fileHeadOf(probe.prefix);
+        }
+    }
+    /** Drops the recorded first bytes (the reader restarted); the next {@link record} with a probe sets them again. */
+    discardHead() {
+        this.head = null;
+    }
+    /** Records the file as known from `prefix`, its first `min(HEAD_BYTES, size)` bytes. */
+    adoptPrefix(stat, prefix) {
+        this.identity = { dev: stat.dev, ino: stat.ino };
+        this.lastMtimeMs = stat.mtimeMs;
+        this.head = fileHeadOf(prefix);
+    }
+    /** Forgets the file, so the next {@link check} adopts whatever file has the path. */
+    forget() {
+        this.identity = null;
+        this.head = null;
+        this.lastMtimeMs = -1;
+        this.checked = null;
+    }
+    /**
+     * Applies the rules to the file open on `fd` (`stat` from `fstat` on that
+     * descriptor), reading the bytes they need. `readOffset` is how far the
+     * reader has read; `committedOffset` (default `readOffset`) is its
+     * resume-safe position just after a newline. Returns why the reader must
+     * restart from offset 0, or `null`. Call {@link adopt} with the same
+     * `stat` once the reader has acted on the answer.
+     */
+    check(fd, stat, readOffset, committedOffset = readOffset) {
+        const probe = this.needsProbe(stat, readOffset)
+            ? probeFileContinuity(fd, stat, committedOffset)
+            : null;
+        const reason = this.reasonFor(stat, readOffset, probe);
+        this.checked = { probe, reset: reason !== null };
+        return reason;
+    }
+    /** Records the file just checked as the one the reader's offsets now refer to. */
+    adopt(stat) {
+        const checked = this.checked;
+        this.checked = null;
+        if (checked?.reset)
+            this.head = null;
+        this.record(stat, checked?.probe ?? null);
+    }
+}
+/** Reads the bytes {@link FileContinuity.reasonFor} compares, from the file open on `fd`. */
+export function probeFileContinuity(fd, stat, committedOffset) {
+    return {
+        prefix: readAt(fd, 0, Math.min(HEAD_BYTES, stat.size)),
+        before: committedOffset > 0 && committedOffset <= stat.size
+            ? readAt(fd, committedOffset - 1, 1)
+            : null,
+    };
+}
+function readAt(fd, position, length) {
+    const buffer = Buffer.alloc(length);
+    const count = length > 0 ? fs.readSync(fd, buffer, 0, length, position) : 0;
+    return buffer.subarray(0, count);
+}

package/dist/esm/formatters/toolSummary.js

@@ -7,6 +7,7 @@
  *
  * @module formatters/toolSummary
  */
+import { ownValue } from '../ownKey';
 // ── Helpers ──
 function truncate(text, maxLen) {
     const clean = text.replace(/\s+/g, ' ').trim();
@@ -171,6 +172,8 @@ const TOOL_FORMATTERS = {
     Bash: formatBash,
     Grep: formatGrep,
     Glob: formatGlob,
+    // Claude Code's subagent tool; `Task` is its earlier name.
+    Agent: formatTask,
     Task: formatTask,
     WebFetch: formatWebFetch,
     WebSearch: formatWebSearch,
@@ -214,7 +217,7 @@ function genericFallback(input) {
 export function formatToolSummary(toolName, input) {
     // Strip MCP prefixes: "mcp__server__tool" → use "tool" for matching
     const baseName = toolName.includes('__') ? (toolName.split('__').pop() ?? toolName) : toolName;
-    const formatter = TOOL_FORMATTERS[toolName] ?? TOOL_FORMATTERS[baseName];
+    const formatter = ownValue(TOOL_FORMATTERS, toolName) ?? ownValue(TOOL_FORMATTERS, baseName);
     if (formatter) {
         const result = formatter(input);
         if (result)

package/dist/esm/index.js

@@ -51,6 +51,7 @@ export { ClaudeCodeProvider } from './providers/claudeCode';
 export { OpenCodeProvider, getOpenCodeDataDir } from './providers/openCode';
 export { CodexProvider, findCodexRolloutFile } from './providers/codex';
 export { walkRolloutFiles, walkRolloutFilesAsync } from './providers/rolloutWalker';
+export { COMPRESSED_ROLLOUT_SUFFIX, isCompressedRolloutPath, isZstdDecompressionAvailable, readRolloutBuffer, readRolloutText, resolveRolloutPath, } from './providers/compressedRollouts';
 // Parsers — JSONL
 export { JsonlParser, TRUNCATION_PATTERNS } from './parsers/jsonl';
 // Parsers — OpenCode
@@ -58,6 +59,7 @@ export { normalizeToolName, normalizeToolInput, detectPlanModeFromText, convertO
 // Parsers — Codex
 export { CodexRolloutParser, DEFAULT_MAX_TRACKED_TOOL_CALLS, extractPatchFilePaths, normalizeCodexToolName, normalizeCodexToolInput, resolveCodexCallUsage, } from './parsers/codexParser';
 export { codexRolloutOrigin, codexSpawnParentFromSource } from './parsers/codexRolloutOrigin';
+export { SUBAGENT_ACTIVITY_BLOCK_TYPE, SUBAGENT_ACTIVITY_ORIGIN_KIND, describeSubagentActivity, isSubagentActivitySystemEvent, parseCodexAgentMessageText, subagentActivityFromEvent, } from './subagentActivity';
 // Parsers — Subagent scanning
 export { scanSubagentDir, extractTaskInfo, readAgentMeta } from './parsers/subagentScanner';
 // Usage — split-line dedupe, subagent tokens, session totals
@@ -80,13 +82,16 @@ export { listSessionPreviews, listSessionPreviewsAsync, readSessionPreview, read
 export { parseDebugLog, filterByLevel, collapseDuplicates, discoverDebugLogs, } from './parsers/debugLogParser';
 // Database wrappers
 export { OpenCodeDatabase } from './providers/openCodeDatabase';
-export { CodexDatabase } from './providers/codexDatabase';
+export { CodexDatabase, isCodexSubagentThread } from './providers/codexDatabase';
 // Search
 export { searchSessions } from './search/sessionSearch';
 export { FilterEngine } from './search/advancedFilter';
 // Context
 export { composeContext } from './context/composer';
 export { buildSessionContextSnapshot, calculateSessionContextPressure, createSessionContextProjector, readSessionContextSnapshot, } from './context/sessionContext';
+// Subagent spawns (`Agent` / `Task`) and background-task notifications
+export { SUBAGENT_SPAWN_TOOL_NAMES, agentsStoppedNoticeFromEvent, isAgentsKilledSystemEvent, isCodexSubagentSpawnTool, isSubagentSpawnTool, isTaskNotificationSystemEvent, isTaskStatusSystemEvent, parseAgentsStoppedNotice, parseCodexSpawnLaunch, parseTaskNotification, taskNotificationFromEvent, taskStatusFromAttachment, taskStatusFromEvent, } from './subagentSpawn';
+export { SUBAGENT_PARENT_IDLE_ENDED_MS, SUBAGENT_UNREPORTED_QUIET_MS, resolveSubagentDisplayState, subagentDisplayLabel, } from './subagentDisplayState';
 // Assistant turn projection
 export { assistantTurnEventsFromSessionEvents, extractTurnSubagents, isAssistantTurnSubagentTool, reasoningSummary, segmentAssistantTurn, } from './turns/assistantTurn';
 // Plan Extraction
@@ -95,7 +100,7 @@ export { PlanExtractor, parsePlanMarkdown as parsePlanMarkdownShared, extractPro
 export { parseChangelog } from './parsers/changelogParser';
 export { createWatcher, resolveSessionPath } from './watchers/factory';
 export { toFollowEvents } from './watchers/eventBridge';
-export { createJsonlTail, DEFAULT_JSONL_TAIL_MAX_LINE_BYTES, DEFAULT_JSONL_TAIL_READ_BYTES, JSONL_TAIL_CHECKPOINT_VERSION, JsonlTailSymlinkError, } from './watchers/jsonlTail';
+export { captureJsonlCheckpoint, createJsonlTail, DEFAULT_JSONL_TAIL_MAX_LINE_BYTES, DEFAULT_JSONL_TAIL_READ_BYTES, JSONL_TAIL_CHECKPOINT_VERSION, JsonlTailSymlinkError, verifyJsonlCheckpoint, } from './watchers/jsonlTail';
 // Formatters
 export { addLocalDays, formatDurationMs, formatLocalDateKey, formatTokenCount, parseLocalDateKey, } from './formatting';
 export { formatToolSummary } from './formatters/toolSummary';

package/dist/esm/modelCatalog.js

@@ -1,3 +1,4 @@
+import { setOwnValue } from './ownKey';
 import { _getModelContextIds, _setImportedResolvedContextWindows, resolveModelContextWindow, } from './modelContext';
 import { _getModelPricingIds, _setImportedResolvedPricing, resolveModelPricing, } from './modelInfo';
 import { _getModelAliases, _importModelAliases, registerModelAlias, resolveModelAlias, } from './modelAliases';
@@ -24,13 +25,13 @@ export function exportResolvedModelCatalog(ids) {
     const selectedIds = normalizedIds(ids);
     for (const id of selectedIds) {
         const canonicalId = resolveModelAlias(id);
-        models[id] = {
+        setOwnValue(models, id, {
             id,
             canonicalId,
             contextWindow: resolveModelContextWindow(id),
             // Registered prices are this realm's local configuration, never exported.
             pricing: resolveModelPricing(id, { includeRegistered: false }),
-        };
+        });
     }
     const selectedCanonicalIds = new Set(Object.values(models).flatMap(({ id, canonicalId }) => [id, canonicalId]));
     const aliases = Object.fromEntries(Object.entries(_getModelAliases()).filter(([alias, canonicalId]) => selectedCanonicalIds.has(alias) || selectedCanonicalIds.has(canonicalId)));
@@ -75,9 +76,9 @@ export function importResolvedModelCatalog(snapshot) {
             if (!id)
                 continue;
             if (contextResolved)
-                contexts[id] = context;
+                setOwnValue(contexts, id, context);
             if (pricingResolved)
-                prices[id] = pricing;
+                setOwnValue(prices, id, pricing);
         }
         imported++;
     }

package/dist/esm/modelContext.js

@@ -28,6 +28,7 @@
  * webviews. Same pattern as `_setPricingOverrides` in `modelInfo.ts`.
  */
 import { resolveModelAlias } from './modelAliases';
+import { ownValue, setOwnValue } from './ownKey';
 /** Known model context window sizes (in tokens); current models verified 2026-09-05. */
 const MODEL_CONTEXT_SIZES = {
     // Published API limits verified 2026-10-30; GLM's API documents 1M even
@@ -144,7 +145,7 @@ function normalizeOverrides(overrides) {
     for (const [key, value] of Object.entries(overrides)) {
         if (!Number.isFinite(value) || value <= 0)
             continue;
-        out[key.trim().toLowerCase()] = value;
+        setOwnValue(out, key.trim().toLowerCase(), value);
     }
     return out;
 }
@@ -208,7 +209,7 @@ export function _getModelContextIds() {
 // ── Lookup ──
 /** Exact match against one table. */
 function exactWindow(table, modelId) {
-    const hit = table[modelId];
+    const hit = ownValue(table, modelId);
     return hit === undefined ? null : hit;
 }
 function exactWindowMatch(table, modelId) {
@@ -256,7 +257,7 @@ export function resolveModelContextWindow(modelId) {
     // Imported resolutions rank below local observed data: a window this realm
     // saw first-hand is fresher than a snapshot transferred from another realm.
     if (!observedExact) {
-        const imported = importedTable[stripped] ?? importedTable[canonicalModelId];
+        const imported = ownValue(importedTable, stripped) ?? ownValue(importedTable, canonicalModelId);
         if (imported) {
             return { ...imported, modelId: rawModelId, canonicalModelId };
         }

package/dist/esm/modelInfo.js

@@ -23,6 +23,7 @@
  */
 import { getModelContextWindowSize } from './modelContext';
 import { resolveModelAlias } from './modelAliases';
+import { ownValue } from './ownKey';
 export { MODEL_PROVIDER_IDS } from './providerIds';
 export { formatCost } from './formatting';
 // ── Static Pricing Table ──
@@ -1078,11 +1079,11 @@ export function resolveModelPricing(modelId, options) {
     });
     if (registered && !registered.entry.onlyIfMissing)
         return registeredResult(registered);
-    const imported = importedTable[rawId] ?? importedTable[aliasId];
+    const imported = ownValue(importedTable, rawId) ?? ownValue(importedTable, aliasId);
     if (imported)
         return { ...imported, modelId, canonicalModelId: aliasId };
     for (const id of candidateIds) {
-        const exactOverride = overrideTable[id];
+        const exactOverride = ownValue(overrideTable, id);
         if (exactOverride) {
             return {
                 modelId,
@@ -1098,7 +1099,7 @@ export function resolveModelPricing(modelId, options) {
         }
     }
     for (const id of candidateIds) {
-        const exactStatic = PRICING_TABLE[id];
+        const exactStatic = ownValue(PRICING_TABLE, id);
         if (exactStatic) {
             return {
                 modelId,

package/dist/esm/node.js

@@ -24,6 +24,7 @@ export { ACTIVE_SESSION_MTIME_THRESHOLD_MS, importSessionHistory, } from './usag
 export { bucketUsage, summarizeUsageRows, usageBucketKey, weekKey } from './usage/usageReports';
 export { findCodexRolloutFile } from './providers/codex';
 export { walkRolloutFiles, walkRolloutFilesAsync } from './providers/rolloutWalker';
+export { COMPRESSED_ROLLOUT_SUFFIX, isCompressedRolloutPath, isZstdDecompressionAvailable, readRolloutBuffer, readRolloutText, resolveRolloutPath, } from './providers/compressedRollouts';
 export { readCodexHistory } from './parsers/codexHistory';
 export { listSessionPreviews, listSessionPreviewsAsync, readSessionPreview, readSessionPreviewAsync, } from './sessionPreviews';
 export { ObservedSessionCollector, observedSessionSourceFromProvider, fileFingerprint, fileFingerprintParts, } from './observedSessionCollector';
@@ -41,6 +42,7 @@ export { parseAuthJson as parseCodexAuthJson, readAuthIdentityFromRaw as readCod
 export { atomicWriteJson, atomicWriteJsonSync } from './writers/atomic';
 export { parseClaudeAuthStatus, parseCodexLoginStatus } from './authStatus';
 export { codexRolloutOrigin, codexSpawnParentFromSource } from './parsers/codexRolloutOrigin';
+export { SUBAGENT_ACTIVITY_BLOCK_TYPE, SUBAGENT_ACTIVITY_ORIGIN_KIND, describeSubagentActivity, isSubagentActivitySystemEvent, parseCodexAgentMessageText, subagentActivityFromEvent, } from './subagentActivity';
 export { getPricingCatalogInfo, registerModelPricing, clearRegisteredModelPricing, } from './modelInfo';
 export { fetchProviderServiceStatus } from './providerServiceStatus';
 // Tool categories across providers
@@ -49,4 +51,4 @@ export { classifyTool, TOOL_CATEGORIES } from './toolCategory';
 export { resolveWorkspaceRoots } from './workspaceRoots';
 export { discoverWorktreeSiblings, resolveWorktreeMainRepo } from './parsers/sessionPathResolver';
 // Bounded JSONL tail reader
-export { createJsonlTail, DEFAULT_JSONL_TAIL_MAX_LINE_BYTES, DEFAULT_JSONL_TAIL_READ_BYTES, JSONL_TAIL_CHECKPOINT_VERSION, JsonlTailSymlinkError, } from './watchers/jsonlTail';
+export { captureJsonlCheckpoint, createJsonlTail, DEFAULT_JSONL_TAIL_MAX_LINE_BYTES, DEFAULT_JSONL_TAIL_READ_BYTES, JSONL_TAIL_CHECKPOINT_VERSION, JsonlTailSymlinkError, verifyJsonlCheckpoint, } from './watchers/jsonlTail';

package/dist/esm/observedContextWindows.js

@@ -32,6 +32,7 @@
 import { promises as fs } from 'node:fs';
 import * as path from 'node:path';
 import { _setObservedContextWindows, _getObservedContextWindows } from './modelContext';
+import { setOwnValue } from './ownKey';
 import { getConfigDir } from './paths';
 import { updateJsonStoreAtomic } from './writers/atomic';
 // ── Constants ──
@@ -80,7 +81,7 @@ function toOverrideMap(store, now = Date.now()) {
         const observedAt = typeof entry.observedAt === 'string' ? Date.parse(entry.observedAt) : NaN;
         if (Number.isFinite(observedAt) && now - observedAt > OBSERVED_CONTEXT_WINDOW_TTL_MS)
             continue;
-        out[modelId] = window;
+        setOwnValue(out, modelId, window);
     }
     return out;
 }

package/dist/esm/ownKey.js

@@ -0,0 +1,26 @@
+/**
+ * Own-property lookups for plain-object tables indexed by external strings.
+ *
+ * `table[key]` also finds inherited members, so a model id, tool name, or
+ * error code such as `constructor`, `toString`, or `__proto__` would return an
+ * `Object.prototype` member instead of `undefined`.
+ *
+ * @module ownKey
+ */
+const hasOwn = Object.prototype.hasOwnProperty;
+/** The value stored under `key` in `table` itself, or `undefined`. */
+export function ownValue(table, key) {
+    return hasOwn.call(table, key) ? table[key] : undefined;
+}
+/**
+ * Store `value` as an own, enumerable property, even for `__proto__`, which a
+ * plain assignment would treat as a prototype change.
+ */
+export function setOwnValue(table, key, value) {
+    Object.defineProperty(table, key, {
+        value,
+        enumerable: true,
+        writable: true,
+        configurable: true,
+    });
+}