sidekick-shared 0.29.0 → 0.29.1

package/dist/esm/aggregation/EventAggregator.js

@@ -18,6 +18,7 @@ import { HeatmapTracker } from './HeatmapTracker';
 import { PatternExtractor } from './PatternExtractor';
 import { categorizeError } from '../extractors/errorTaxonomy';
 import { estimateTextTokens } from '../tokenEstimation';
+import { isSubagentSpawnTool, isTaskNotificationSystemEvent, parseAsyncAgentLaunch, parseTaskNotification, taskNotificationFromEvent, taskNotificationOutcome, taskNotificationPromptFromAttachment, } from '../subagentSpawn';
 import { calculateNormalizedUsageCost, extractNormalizedUsage, normalizeProviderUsage, } from '../usageNormalization';
 // ── Defaults ──
 const DEFAULT_TIMELINE_CAP = 200;
@@ -30,6 +31,22 @@ const COMPACTION_DROP_THRESHOLD = 0.8; // >20% drop
 export const SNAPSHOT_SCHEMA_VERSION = 6;
 // ── Goal gate detection regex ──
 const GOAL_GATE_REGEX = /\b(CRITICAL|MUST|blocker|required|must.?complete|goal.?gate|essential|do.?not.?skip|blocking)\b/i;
+// ── Task notifications delivered as attachments ──
+/**
+ * The notification a `system` FollowEvent carries when it stands for a
+ * mid-turn task-notification attachment (its `raw` is the attachment line or
+ * the SessionEvent `extractSessionEvents` made from it).
+ */
+function taskNotificationFromAttachmentFollowEvent(event) {
+    const raw = event.raw;
+    if (!raw || typeof raw !== 'object')
+        return null;
+    const prompt = taskNotificationPromptFromAttachment(raw);
+    if (prompt !== null)
+        return parseTaskNotification(prompt);
+    const asEvent = raw;
+    return isTaskNotificationSystemEvent(asEvent) ? taskNotificationFromEvent(asEvent) : null;
+}
 // ── Todo dependency parsing ──
 /**
  * Parses dependency references from a todo item's content text.
@@ -168,6 +185,17 @@ export class EventAggregator {
     // processEvent — main entry for SessionEvent
     // ═══════════════════════════════════════════════════════════════════════
     processEvent(event) {
+        // Opt-in mid-turn task notifications (`extractSessionEvents` with
+        // `includeTaskNotifications`) only finish background subagents and mark
+        // the timeline: they are not messages, prompts, context, or activity.
+        if (isTaskNotificationSystemEvent(event)) {
+            const notification = taskNotificationFromEvent(event);
+            if (notification) {
+                this.applyTaskNotification(notification, event.timestamp);
+                this.addTaskNotificationTimeline(event.timestamp, notification);
+            }
+            return;
+        }
         // 1. Increment counters, capture timestamps
         this.eventCount++;
         if (!this.sessionStartTime) {
@@ -233,6 +261,15 @@ export class EventAggregator {
     // processFollowEvent — adapter for CLI FollowEvent format
     // ═══════════════════════════════════════════════════════════════════════
     processFollowEvent(event) {
+        // A mid-turn task-notification attachment, like its SessionEvent form above.
+        if (event.type === 'system') {
+            const notification = taskNotificationFromAttachmentFollowEvent(event);
+            if (notification) {
+                this.applyTaskNotification(notification, event.timestamp);
+                this.addTaskNotificationTimeline(event.timestamp, notification);
+                return;
+            }
+        }
         // 1. Increment counters, capture timestamps
         this.eventCount++;
         if (!this.sessionStartTime) {
@@ -626,6 +663,14 @@ export class EventAggregator {
         this.pendingToolCalls.clear();
         this.pendingTaskCreates.clear();
         this.pendingSubagents.clear();
+        // A spawn still waiting for its tool_result is resolved by that result,
+        // which can land after the snapshot boundary. Background agents need no
+        // entry: their notifications are matched against every subagent.
+        this.subagents.forEach((agent, idx) => {
+            if (agent.status === 'running' && !agent.background && agent.id) {
+                this.pendingSubagents.set(agent.id, idx);
+            }
+        });
         this.pendingUserRequest = null;
         this.planExtractor.reset();
         return true;
@@ -1104,7 +1149,7 @@ export class EventAggregator {
                 else if (name === 'UpdatePlan') {
                     this.handleUpdatePlan(input, new Date(event.timestamp));
                 }
-                else if ((name === 'Agent' || name === 'Task') && toolUseId) {
+                else if (isSubagentSpawnTool(name) && toolUseId) {
                     this.handleAgentSpawn(toolUseId, input, new Date(event.timestamp));
                 }
             }
@@ -1114,7 +1159,7 @@ export class EventAggregator {
                     continue;
                 const isError = block.is_error ?? false;
                 this.resolveTaskCreate(toolUseId, block.content ?? block.output, event.timestamp, isError);
-                this.resolveAgentResult(toolUseId, isError, event.timestamp);
+                this.resolveAgentResult(toolUseId, isError, event.timestamp, block.content ?? block.output);
             }
         }
     }
@@ -1148,7 +1193,7 @@ export class EventAggregator {
             else if (event.toolName === 'UpdatePlan') {
                 this.handleUpdatePlan(input, new Date(event.timestamp));
             }
-            else if ((event.toolName === 'Agent' || event.toolName === 'Task') && toolUseId) {
+            else if (isSubagentSpawnTool(event.toolName) && toolUseId) {
                 this.handleAgentSpawn(toolUseId, input, new Date(event.timestamp));
             }
         }
@@ -1160,7 +1205,7 @@ export class EventAggregator {
                 return;
             const isError = raw.is_error ?? false;
             this.resolveTaskCreate(toolUseId, raw.content, event.timestamp, isError);
-            this.resolveAgentResult(toolUseId, isError, event.timestamp);
+            this.resolveAgentResult(toolUseId, isError, event.timestamp, raw.content);
         }
     }
     applyTaskUpdate(input) {
@@ -1465,11 +1510,14 @@ export class EventAggregator {
         };
         this.tasks.set(agentTaskId, task);
     }
-    resolveAgentResult(toolUseId, isError, timestamp) {
+    resolveAgentResult(toolUseId, isError, timestamp, content) {
         const agentTaskId = `agent-${toolUseId}`;
         const agentTask = this.tasks.get(agentTaskId);
         if (!agentTask)
             return;
+        // A background launch returns at once; its task notification finishes it.
+        if (!isError && parseAsyncAgentLaunch(content))
+            return;
         agentTask.status = isError ? 'deleted' : 'completed';
         agentTask.updatedAt = new Date(timestamp);
     }
@@ -1489,31 +1537,25 @@ export class EventAggregator {
     // Private: Subagent Tracking from SessionEvent
     // ═══════════════════════════════════════════════════════════════════════
     extractSubagentFromEvent(event) {
+        const notification = taskNotificationFromEvent(event);
+        if (notification)
+            this.applyTaskNotification(notification, event.timestamp);
         const content = event.message?.content;
         if (!Array.isArray(content))
             return;
         for (const block of content) {
-            if (block.type === 'tool_use' && block.name === 'Task') {
+            if (block.type === 'tool_use' && isSubagentSpawnTool(block.name)) {
                 const input = block.input;
                 const toolUseId = block.id;
                 if (!input || !toolUseId)
                     continue;
-                const info = {
-                    id: toolUseId,
-                    description: input.description || 'Unknown task',
-                    subagentType: input.subagent_type || input.subagentType || 'general',
-                    spawnTime: event.timestamp,
-                    status: 'running',
-                };
-                const idx = this.subagents.length;
-                this.subagents.push(info);
-                this.pendingSubagents.set(toolUseId, idx);
+                this.trackSubagentSpawn(toolUseId, input, event.timestamp);
             }
             else if (block.type === 'tool_result') {
                 const toolUseId = block.tool_use_id;
                 if (!toolUseId)
                     continue;
-                this.completeSubagent(toolUseId, event.timestamp);
+                this.resolveSubagentResult(toolUseId, block.content ?? block.output, block.is_error === true, event.timestamp);
             }
         }
     }
@@ -1522,23 +1564,10 @@ export class EventAggregator {
     // ═══════════════════════════════════════════════════════════════════════
     extractSubagentFromFollowEvent(event) {
         const raw = event.raw;
-        if (event.type === 'tool_use' && event.toolName === 'Task') {
+        if (event.type === 'tool_use' && isSubagentSpawnTool(event.toolName)) {
             if (!raw?.input)
                 return;
-            const input = raw.input;
-            const toolUseId = raw.id || '';
-            const info = {
-                id: toolUseId,
-                description: input.description || 'Unknown task',
-                subagentType: input.subagent_type || input.subagentType || 'general',
-                spawnTime: event.timestamp,
-                status: 'running',
-            };
-            const idx = this.subagents.length;
-            this.subagents.push(info);
-            if (toolUseId) {
-                this.pendingSubagents.set(toolUseId, idx);
-            }
+            this.trackSubagentSpawn(raw.id || '', raw.input, event.timestamp);
         }
         else if (event.type === 'tool_result') {
             if (!raw)
@@ -1546,23 +1575,133 @@ export class EventAggregator {
             const toolUseId = raw.tool_use_id;
             if (!toolUseId)
                 return;
-            this.completeSubagent(toolUseId, event.timestamp);
+            this.resolveSubagentResult(toolUseId, raw.content, raw.is_error === true, event.timestamp);
+        }
+        else if (event.type === 'user' && raw?.type === 'user') {
+            // Claude Code delivers most task notifications as their own user line.
+            const notification = taskNotificationFromEvent(raw);
+            if (notification)
+                this.applyTaskNotification(notification, event.timestamp);
+        }
+    }
+    trackSubagentSpawn(toolUseId, input, timestamp) {
+        const info = {
+            id: toolUseId,
+            description: input.description || 'Unknown task',
+            subagentType: input.subagent_type || input.subagentType || 'general',
+            spawnTime: timestamp,
+            status: 'running',
+        };
+        const idx = this.subagents.length;
+        this.subagents.push(info);
+        if (toolUseId) {
+            this.pendingSubagents.set(toolUseId, idx);
         }
     }
-    completeSubagent(toolUseId, timestamp) {
+    /**
+     * The spawning tool call's result. A foreground agent ends here; a
+     * background launch only reports the agent id, and the agent keeps running
+     * until its task notification arrives.
+     */
+    resolveSubagentResult(toolUseId, content, isError, timestamp) {
         const idx = this.pendingSubagents.get(toolUseId);
         if (idx === undefined)
             return;
-        this.pendingSubagents.delete(toolUseId);
+        const launch = isError ? null : parseAsyncAgentLaunch(content);
+        if (launch) {
+            this.markBackgroundLaunch(idx, launch);
+            return;
+        }
+        this.completeSubagent(toolUseId, timestamp, isError ? 'failed' : 'completed');
+    }
+    markBackgroundLaunch(idx, launch) {
         const agent = this.subagents[idx];
+        this.pendingSubagents.delete(agent.id);
+        agent.background = true;
+        if (launch.agentId)
+            agent.agentId = launch.agentId;
+    }
+    completeSubagent(toolUseId, timestamp, outcome = 'completed') {
+        const idx = this.pendingSubagents.get(toolUseId);
+        if (idx === undefined)
+            return;
+        this.finishSubagent(this.subagents[idx], timestamp, outcome);
+    }
+    finishSubagent(agent, timestamp, outcome) {
+        this.pendingSubagents.delete(agent.id);
         agent.status = 'completed';
         agent.completionTime = timestamp;
+        agent.outcome = outcome;
         const start = new Date(agent.spawnTime).getTime();
         const end = new Date(timestamp).getTime();
         if (!isNaN(start) && !isNaN(end) && end >= start) {
             agent.durationMs = end - start;
         }
     }
+    /**
+     * Applies a background task's notification to the subagent it reports on,
+     * matched by the spawning tool_use id (or by agent id when the notification
+     * has none). The latest notification wins: an interim one ("waiting on its
+     * own background work") keeps or puts the agent back to running, a final one
+     * completes it. Notifications for background shell tasks match nothing.
+     */
+    applyTaskNotification(notification, timestamp) {
+        const agent = this.findNotifiedSubagent(notification);
+        const toolUseId = agent?.id || notification.toolUseId;
+        const outcome = taskNotificationOutcome(notification.status);
+        if (agent) {
+            agent.background = true;
+            if (!agent.agentId)
+                agent.agentId = notification.taskId;
+            if (notification.interim) {
+                this.pendingSubagents.delete(agent.id);
+                agent.status = 'running';
+                delete agent.completionTime;
+                delete agent.durationMs;
+                delete agent.outcome;
+            }
+            else {
+                this.finishSubagent(agent, timestamp, outcome);
+            }
+        }
+        const agentTask = toolUseId ? this.tasks.get(`agent-${toolUseId}`) : undefined;
+        if (agentTask?.isSubagent) {
+            agentTask.status = notification.interim
+                ? 'in_progress'
+                : outcome === 'failed'
+                    ? 'deleted'
+                    : 'completed';
+            agentTask.updatedAt = new Date(timestamp);
+        }
+    }
+    findNotifiedSubagent(notification) {
+        const { toolUseId, taskId } = notification;
+        for (let i = this.subagents.length - 1; i >= 0; i--) {
+            if (toolUseId && this.subagents[i].id === toolUseId)
+                return this.subagents[i];
+        }
+        for (let i = this.subagents.length - 1; i >= 0; i--) {
+            if (this.subagents[i].agentId === taskId)
+                return this.subagents[i];
+        }
+        return undefined;
+    }
+    addTaskNotificationTimeline(timestamp, notification) {
+        let description = notification.summary ?? `Background task ${notification.status ?? 'finished'}`;
+        if (description.length > 200)
+            description = description.substring(0, 197) + '...';
+        this.timeline.push({
+            type: 'tool_result',
+            timestamp,
+            description,
+            noiseLevel: 'system',
+            messageClassification: 'system',
+            ...(notification.toolUseId ? { metadata: { toolUseId: notification.toolUseId } } : {}),
+        });
+        if (this.timeline.length > this.timelineCap) {
+            this.timeline.shift();
+        }
+    }
     // ═══════════════════════════════════════════════════════════════════════
     // Private: Plan Extraction from SessionEvent
     // ═══════════════════════════════════════════════════════════════════════

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,7 @@ 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, isSubagentSpawnTool, isTaskNotificationSystemEvent, parseTaskNotification, taskNotificationFromEvent, } from './subagentSpawn';
 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';

package/dist/esm/context/sessionContext.js

@@ -8,6 +8,7 @@ import { EventAggregator } from '../aggregation/EventAggregator';
 import { getModelContextWindowSize } from '../modelContext';
 import { parseMcpToolName } from '../parsers/mcpToolName';
 import { estimateTextTokens } from '../tokenEstimation';
+import { isTaskNotificationSystemEvent } from '../subagentSpawn';
 const DEFAULT_CONTEXT_SOURCE_LIMIT = 200;
 const DEFAULT_SNIPPET_MAX_CHARS = 240;
 const DEFAULT_BODY_MAX_CHARS = 5000;
@@ -205,6 +206,9 @@ function extractSourcesFromEvent(event, state) {
     }
 }
 function extractSystemSource(event, state) {
+    // Background-task notices only update subagent lifecycles (like the aggregator).
+    if (isTaskNotificationSystemEvent(event))
+        return;
     const message = event.message;
     const text = extractText(message?.content);
     const label = message?.sourceLabel ?? message?.role ?? 'system';

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

@@ -87,6 +87,8 @@ 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, isSubagentSpawnTool, isTaskNotificationSystemEvent, parseTaskNotification, taskNotificationFromEvent, } from './subagentSpawn';
 // Assistant turn projection
 export { assistantTurnEventsFromSessionEvents, extractTurnSubagents, isAssistantTurnSubagentTool, reasoningSummary, segmentAssistantTurn, } from './turns/assistantTurn';
 // Plan Extraction
@@ -95,7 +97,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

@@ -49,4 +49,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,
+    });
+}