sidekick-shared 0.24.0 → 0.24.2

package/dist/observedContextWindows.js

@@ -0,0 +1,150 @@
+"use strict";
+/**
+ * Persisted record of context windows providers actually reported (Node-only).
+ *
+ * Some agents report the real context window for the running session — Codex
+ * emits `model_context_window` on every `token_count` event. That number is the
+ * *effective* window for the account and tier, which can sit well below the
+ * model's published maximum (e.g. 258,400 observed for `gpt-5.6-sol` against a
+ * catalog maximum of 1,050,000).
+ *
+ * A live session uses that value directly. This module keeps it across runs, so
+ * historical and static views don't fall back to a published maximum that would
+ * make the context gauge read far too empty.
+ *
+ * Precedence, most-trusted first: runtime → observed (here) → LiteLLM catalog →
+ * static table. See `modelContext.ts`.
+ *
+ * @module observedContextWindows
+ */
+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.getObservedContextWindowPath = getObservedContextWindowPath;
+exports.loadObservedContextWindows = loadObservedContextWindows;
+exports.recordObservedContextWindow = recordObservedContextWindow;
+const node_fs_1 = require("node:fs");
+const path = __importStar(require("node:path"));
+const modelContext_1 = require("./modelContext");
+const paths_1 = require("./paths");
+const atomic_1 = require("./writers/atomic");
+// ── Constants ──
+const STORE_FILE_NAME = 'observed-context-windows.json';
+const STORE_VERSION = 1;
+/** Resolve the on-disk store path. */
+function getObservedContextWindowPath(cacheDir) {
+    return path.join(cacheDir ?? (0, paths_1.getConfigDir)(), STORE_FILE_NAME);
+}
+function emptyStore() {
+    return { version: STORE_VERSION, models: {} };
+}
+/** Keep only well-formed entries; a hand-edited or partly-corrupt file shouldn't poison lookups. */
+function toOverrideMap(store) {
+    const out = {};
+    for (const [modelId, entry] of Object.entries(store.models ?? {})) {
+        const window = entry?.contextWindow;
+        if (typeof window !== 'number' || !Number.isFinite(window) || window <= 0)
+            continue;
+        out[modelId] = window;
+    }
+    return out;
+}
+// ── Public API ──
+/**
+ * Load persisted observations and apply them as context-window overrides.
+ *
+ * Always resolves — never throws. A missing, unreadable, or malformed store
+ * leaves the overrides empty and lookups fall through to catalog/static.
+ */
+async function loadObservedContextWindows(options = {}) {
+    const storePath = getObservedContextWindowPath(options.cacheDir);
+    try {
+        const raw = await node_fs_1.promises.readFile(storePath, 'utf8');
+        const parsed = JSON.parse(raw);
+        if (!parsed || typeof parsed !== 'object' || !parsed.models)
+            return {};
+        const overrides = toOverrideMap(parsed);
+        (0, modelContext_1._setObservedContextWindows)(overrides);
+        return overrides;
+    }
+    catch (err) {
+        const code = err.code;
+        if (code !== 'ENOENT') {
+            options.logger?.(`observedContextWindows: failed to load ${storePath}: ${String(err)}`);
+        }
+        return {};
+    }
+}
+/**
+ * Record a provider-reported context window for a model.
+ *
+ * Applies in memory immediately, then persists — but only when the value
+ * actually changed. Codex reports a window on every `token_count` event, so an
+ * unconditional write would mean disk I/O many times per session for a value
+ * that almost never moves.
+ *
+ * Always resolves — never throws. Persistence failures are logged and dropped;
+ * the in-memory override still stands for this process.
+ */
+async function recordObservedContextWindow(modelId, contextWindow, options = {}) {
+    const normalizedId = modelId?.trim().toLowerCase();
+    if (!normalizedId)
+        return;
+    if (!Number.isFinite(contextWindow) || contextWindow <= 0)
+        return;
+    const current = (0, modelContext_1._getObservedContextWindows)();
+    if (current[normalizedId] === contextWindow)
+        return;
+    (0, modelContext_1._setObservedContextWindows)({ ...current, [normalizedId]: contextWindow });
+    const storePath = getObservedContextWindowPath(options.cacheDir);
+    try {
+        // Lock-guarded read-modify-write: the CLI and the extension host can both
+        // be observing sessions at once, and each should merge rather than clobber.
+        await (0, atomic_1.updateJsonStoreAtomic)(storePath, emptyStore, (latest) => {
+            const models = latest?.models ?? {};
+            if (models[normalizedId]?.contextWindow === contextWindow)
+                return latest;
+            return {
+                version: STORE_VERSION,
+                models: {
+                    ...models,
+                    [normalizedId]: { contextWindow, observedAt: new Date().toISOString() },
+                },
+            };
+        });
+    }
+    catch (err) {
+        options.logger?.(`observedContextWindows: failed to persist ${storePath}: ${String(err)}`);
+    }
+}

package/dist/observedSessionCollector.d.ts

@@ -1,4 +1,4 @@
-import type { ObservedAgentSessionV1 } from './types/observedSessionV1';
+import type { ObservedAgentSessionV1, ProviderCapabilitiesV1 } from './types/observedSessionV1';
 import type { SessionProviderBase } from './providers/types';
 export interface ObservedSessionReference {
     sessionId: string;
@@ -12,6 +12,9 @@ export interface ObservedSessionCollectionSource<T = unknown> {
     read(reference: ObservedSessionReference): Promise<T> | T;
     dispose?(): void;
 }
+export interface ProviderObservedSessionCollectionSource extends ObservedSessionCollectionSource<ObservedAgentSessionV1> {
+    capabilities: ProviderCapabilitiesV1;
+}
 export type ObservedSessionDiagnosticKind = 'provider-discovery-failed' | 'session-read-failed' | 'provider-recovered' | 'session-recovered';
 /** Content-safe diagnostics: identifiers and retry metadata only. */
 export interface ObservedSessionDiagnostic {
@@ -63,6 +66,6 @@ export declare class ObservedSessionCollector<T = unknown> {
  * Adapt a provider using path-only discovery and independent adapter reads, so
  * one malformed session cannot reject discovery of its healthy siblings.
  */
-export declare function observedSessionSourceFromProvider(provider: SessionProviderBase, cwd: string): ObservedSessionCollectionSource<ObservedAgentSessionV1>;
+export declare function observedSessionSourceFromProvider(provider: SessionProviderBase, cwd: string): ProviderObservedSessionCollectionSource;
 /** Size/mtime fingerprint suitable for retry bypass; returns null for synthetic DB locators. */
 export declare function fileFingerprint(sourcePath: string): string | null;

package/dist/observedSessionCollector.js

@@ -144,6 +144,7 @@ function observedSessionSourceFromProvider(provider, cwd) {
     const adapter = (0, observedSessionV1_1.createProviderSessionAdapterV1)(provider);
     return {
         providerId: provider.id,
+        capabilities: adapter.capabilities,
         discover() {
             return provider.findAllSessions(cwd).map((sessionPath) => ({
                 sessionId: provider.getSessionId(sessionPath),

package/dist/parsers/codexParser.js

@@ -200,18 +200,21 @@ class CodexRolloutParser {
     handleSessionMeta(timestamp, payload) {
         this.sessionMeta = payload;
         const text = payload.base_instructions?.text?.trim();
-        if (!text)
-            return [];
         return [
             {
                 type: 'system',
-                message: {
-                    role: 'system',
-                    id: `${payload.id}:base-instructions`,
-                    sourceLabel: 'base instructions',
-                    content: [{ type: 'text', text }],
-                },
+                ...(text
+                    ? {
+                        message: {
+                            role: 'system',
+                            id: `${payload.id}:base-instructions`,
+                            sourceLabel: 'base instructions',
+                            content: [{ type: 'text', text }],
+                        },
+                    }
+                    : {}),
                 timestamp,
+                cwd: payload.cwd || undefined,
             },
         ];
     }

package/dist/pricingCatalog.d.ts

@@ -36,6 +36,8 @@ export interface HydrateResult {
     source: 'cache' | 'network' | 'offline';
     /** Number of pricing entries applied to the override map. */
     entries: number;
+    /** Number of context-window entries applied to the override map. */
+    contextWindowEntries: number;
     /** ISO timestamp of the fetch that produced the cache. */
     fetchedAt: string;
 }
@@ -56,3 +58,13 @@ export declare function hydratePricingCatalog(options: HydrateOptions): Promise<
  * Exported for tests; rarely called directly.
  */
 export declare function normalizeLiteLlmCatalog(raw: unknown): Record<string, ModelPricing>;
+/**
+ * Convert a LiteLLM catalog payload to a model → context-window override map.
+ *
+ * Kept separate from `normalizeLiteLlmCatalog` rather than folded into its
+ * return type: that function is public API on a published package, and pricing
+ * and context coverage differ (an entry can have one without the other).
+ *
+ * Exported for tests; rarely called directly.
+ */
+export declare function normalizeLiteLlmContextWindows(raw: unknown): Record<string, number>;

package/dist/pricingCatalog.js

@@ -54,8 +54,10 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.LITELLM_CATALOG_URL = void 0;
 exports.hydratePricingCatalog = hydratePricingCatalog;
 exports.normalizeLiteLlmCatalog = normalizeLiteLlmCatalog;
+exports.normalizeLiteLlmContextWindows = normalizeLiteLlmContextWindows;
 const node_fs_1 = require("node:fs");
 const path = __importStar(require("node:path"));
+const modelContext_1 = require("./modelContext");
 const modelInfo_1 = require("./modelInfo");
 // ── Constants ──
 exports.LITELLM_CATALOG_URL = 'https://raw.githubusercontent.com/BerriAI/litellm/main/model_prices_and_context_window.json';
@@ -80,43 +82,51 @@ async function hydratePricingCatalog(options) {
     // 1. Fresh cache?
     const cached = await readCache(cachePath);
     if (cached && now - Date.parse(cached.fetchedAt) < ttlMs) {
-        (0, modelInfo_1._setPricingOverrides)(cached.overrides);
-        return {
-            source: 'cache',
-            entries: Object.keys(cached.overrides).length,
-            fetchedAt: cached.fetchedAt,
-        };
+        return applyCacheFile(cached, 'cache');
     }
     // 2. Try network.
     if (fetchImpl) {
         const fetched = await fetchCatalog(url, fetchImpl, timeoutMs, logger);
         if (fetched) {
-            const overrides = normalizeLiteLlmCatalog(fetched);
             const payload = {
                 fetchedAt: new Date(now).toISOString(),
                 url,
-                overrides,
+                overrides: normalizeLiteLlmCatalog(fetched),
+                contextWindows: normalizeLiteLlmContextWindows(fetched),
             };
             await writeCache(cachePath, payload, logger);
-            (0, modelInfo_1._setPricingOverrides)(overrides);
-            return {
-                source: 'network',
-                entries: Object.keys(overrides).length,
-                fetchedAt: payload.fetchedAt,
-            };
+            return applyCacheFile(payload, 'network');
         }
     }
     // 3. Fall back to stale cache if present.
     if (cached) {
-        (0, modelInfo_1._setPricingOverrides)(cached.overrides);
-        return {
-            source: 'cache',
-            entries: Object.keys(cached.overrides).length,
-            fetchedAt: cached.fetchedAt,
-        };
+        return applyCacheFile(cached, 'cache');
     }
-    // 4. Nothing we can do — stay on static table.
-    return { source: 'offline', entries: 0, fetchedAt: new Date(now).toISOString() };
+    // 4. Nothing we can do — stay on static tables.
+    return {
+        source: 'offline',
+        entries: 0,
+        contextWindowEntries: 0,
+        fetchedAt: new Date(now).toISOString(),
+    };
+}
+/**
+ * Push a cache payload into both override maps and describe what was applied.
+ * `contextWindows` is absent on caches written before context hydration; those
+ * contribute no overrides rather than clearing whatever is already loaded.
+ */
+function applyCacheFile(cache, source) {
+    const contextWindows = cache.contextWindows ?? {};
+    (0, modelInfo_1._setPricingOverrides)(cache.overrides);
+    if (Object.keys(contextWindows).length > 0) {
+        (0, modelContext_1._setCatalogContextWindows)(contextWindows);
+    }
+    return {
+        source,
+        entries: Object.keys(cache.overrides).length,
+        contextWindowEntries: Object.keys(contextWindows).length,
+        fetchedAt: cache.fetchedAt,
+    };
 }
 /**
  * Convert a LiteLLM catalog payload to our `ModelPricing` override map.
@@ -145,6 +155,57 @@ function normalizeLiteLlmCatalog(raw) {
     }
     return out;
 }
+/**
+ * Convert a LiteLLM catalog payload to a model → context-window override map.
+ *
+ * Kept separate from `normalizeLiteLlmCatalog` rather than folded into its
+ * return type: that function is public API on a published package, and pricing
+ * and context coverage differ (an entry can have one without the other).
+ *
+ * Exported for tests; rarely called directly.
+ */
+function normalizeLiteLlmContextWindows(raw) {
+    const out = {};
+    if (!raw || typeof raw !== 'object')
+        return out;
+    // Bare-model aliases are gathered separately rather than written as we go. A
+    // `provider/model` entry describes that *provider's deployment* window, which
+    // is often a truncation of the model's own — the live catalog carries five
+    // different windows for `claude-sonnet-4`, from GitHub Copilot's 128K to
+    // Vertex's 1M. Taking whichever appeared first in the JSON is a coin flip, so
+    // an alias is only promoted when every provider mentioning it agrees.
+    const aliasWindows = new Map();
+    for (const [key, entry] of Object.entries(raw)) {
+        // LiteLLM ships a `sample_spec` header entry. Skip it.
+        if (key === 'sample_spec')
+            continue;
+        if (!entry || typeof entry !== 'object')
+            continue;
+        const window = entry.max_input_tokens;
+        if (typeof window !== 'number' || !Number.isFinite(window) || window <= 0)
+            continue;
+        out[key] = window;
+        const bare = stripProviderPrefix(key);
+        if (bare && bare !== key) {
+            const seen = aliasWindows.get(bare) ?? new Set();
+            seen.add(window);
+            aliasWindows.set(bare, seen);
+        }
+    }
+    for (const [bare, windows] of aliasWindows) {
+        // A top-level entry for the same ID is authoritative — never shadow it.
+        if (out[bare] !== undefined)
+            continue;
+        // Providers disagree, so none of their numbers can be attributed to the
+        // bare model. Record nothing and let a more trusted layer answer.
+        if (windows.size !== 1)
+            continue;
+        const [only] = windows;
+        if (typeof only === 'number')
+            out[bare] = only;
+    }
+    return out;
+}
 // ── Internals ──
 function liteLlmEntryToPricing(entry) {
     const input = entry.input_cost_per_token;

package/dist/providers/codex.js

@@ -53,6 +53,7 @@ const codexParser_1 = require("../parsers/codexParser");
 const codexDatabase_1 = require("./codexDatabase");
 const codexProfiles_1 = require("../codexProfiles");
 const modelContext_1 = require("../modelContext");
+const observedContextWindows_1 = require("../observedContextWindows");
 const usageNormalization_1 = require("../usageNormalization");
 // ---------------------------------------------------------------------------
 // Helper functions
@@ -510,10 +511,12 @@ class CodexReader {
                     // Skip malformed JSON lines
                 }
             }
-            // Propagate model_context_window from token_count events to the provider
+            // Propagate model_context_window from token_count events to the provider.
+            // The model comes along so the value can be persisted per model — the
+            // window Codex reports is tier-specific, not the published maximum.
             const mcw = this.parser.getModelContextWindow();
             if (mcw && this.onContextWindowLimit) {
-                this.onContextWindowLimit(mcw);
+                this.onContextWindowLimit(mcw, this.parser.getCurrentModel() ?? undefined);
             }
             // Propagate rate_limits from token_count events to the provider
             const rateLimits = this.parser.getLastRateLimits();
@@ -791,8 +794,15 @@ class CodexProvider {
     }
     // --- Data reading ---
     createReader(sessionPath) {
-        return new CodexReader(sessionPath, (limit) => {
+        return new CodexReader(sessionPath, (limit, modelId) => {
             this.dynamicContextWindowLimit = limit;
+            if (modelId) {
+                // Fire-and-forget: persist so historical/static views keep this
+                // tier-specific window instead of falling back to the catalog maximum.
+                void (0, observedContextWindows_1.recordObservedContextWindow)(modelId, limit).catch(() => {
+                    /* non-fatal; the in-memory limit above still applies */
+                });
+            }
         }, (limits) => {
             this.lastRateLimitsData = limits;
         }, (usage) => {

package/dist/schemas/index.d.ts

@@ -16,8 +16,8 @@ export { normalizedUsageSchema, normalizedUsageCostSchema } from './usageNormali
 export type { NormalizedUsage, NormalizedUsageCost } from '../usageNormalization';
 export { tokenEstimateSchema } from './tokenEstimation';
 export type { TokenEstimate } from '../tokenEstimation';
-export { canonicalTranscriptBlockSchema, canonicalToolCallSchema, canonicalTranscriptMessageSchema, canonicalSessionTranscriptSchema, } from './transcript';
-export type { CanonicalSessionTranscript, CanonicalTranscriptMessage, CanonicalToolCall, } from '../transcript';
+export { transcriptSourceProvenanceSchema, canonicalTranscriptBlockSchema, canonicalToolCallSchema, canonicalTranscriptMessageSchema, canonicalSessionTranscriptSchema, } from './transcript';
+export type { CanonicalSessionTranscript, CanonicalTranscriptMessage, CanonicalToolCall, TranscriptSourceProvenance, } from '../transcript';
 export { observationProvenanceV1Schema, observedAgentSessionV1Schema, observedValueV1Schema, pendingUserRequestV1Schema, providerCapabilitiesV1Schema, providerSessionAdapterV1Schema, sessionEvidenceRefV1Schema, } from './observedSessionV1';
 export type { ObservationProvenanceV1, ObservedAgentSessionV1, ObservedValueV1, PendingUserRequestV1, ProviderCapabilitiesV1, ProviderSessionAdapterV1, SessionEvidenceRefV1, } from '../types/observedSessionV1';
 export { quotaWindowSchema, quotaStateSchema, quotaFailureKindSchema, quotaProviderIdSchema, quotaSourceSchema, codexResetCreditSchema, codexResetCreditsSnapshotSchema, peakHoursStateSchema, quotaFailureDescriptorSchema, runtimeQuotaProviderSchema, providerQuotaStateSchema, claudeProviderQuotaStateSchema, codexProviderQuotaStateSchema, zaiProviderQuotaStateSchema, providerQuotaMapSchema, } from './quota';

package/dist/schemas/index.js

@@ -12,8 +12,8 @@
  * subpath is self-sufficient for boundary-validation modules.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.accountEntrySchema = exports.accountLoginStatusSchema = exports.beginAccountLoginResultSchema = exports.accountManagerResultSchema = exports.accountProviderIdSchema = exports.activeAccountStatusSchema = exports.activeProviderAccountStatusSchema = exports.quotaHistoryDailyBucketSchema = exports.quotaHistorySampleSchema = exports.quotaHistoryRuntimeProviderSchema = exports.providerQuotaMapSchema = exports.zaiProviderQuotaStateSchema = exports.codexProviderQuotaStateSchema = exports.claudeProviderQuotaStateSchema = exports.providerQuotaStateSchema = exports.runtimeQuotaProviderSchema = exports.quotaFailureDescriptorSchema = exports.peakHoursStateSchema = exports.codexResetCreditsSnapshotSchema = exports.codexResetCreditSchema = exports.quotaSourceSchema = exports.quotaProviderIdSchema = exports.quotaFailureKindSchema = exports.quotaStateSchema = exports.quotaWindowSchema = exports.sessionEvidenceRefV1Schema = exports.providerSessionAdapterV1Schema = exports.providerCapabilitiesV1Schema = exports.pendingUserRequestV1Schema = exports.observedValueV1Schema = exports.observedAgentSessionV1Schema = exports.observationProvenanceV1Schema = exports.canonicalSessionTranscriptSchema = exports.canonicalTranscriptMessageSchema = exports.canonicalToolCallSchema = exports.canonicalTranscriptBlockSchema = exports.tokenEstimateSchema = exports.normalizedUsageCostSchema = exports.normalizedUsageSchema = exports.toolResultSessionEventSchema = exports.toolUseSessionEventSchema = exports.systemSessionEventSchema = exports.summarySessionEventSchema = exports.assistantSessionEventSchema = exports.userSessionEventSchema = exports.extractSessionEvents = exports.permissionModeSchema = exports.sessionEventSchema = exports.sessionMessageSchema = exports.messageUsageSchema = void 0;
-exports.assistantTurnToolRefSchema = exports.assistantTurnToolGroupStepSchema = exports.assistantTurnTimelineItemSchema = exports.assistantTurnSubagentStatusSchema = exports.assistantTurnSubagentSchema = exports.assistantTurnReasoningTimelineItemSchema = exports.assistantTurnProjectionSchema = exports.assistantTurnProcessStepSchema = exports.assistantTurnProcessSchema = exports.assistantTurnNarrationStepSchema = exports.assistantTurnEventTypeSchema = exports.assistantTurnEventSchema = exports.listAllAccountsResultSchema = exports.savedAccountProfileSchema = void 0;
+exports.accountLoginStatusSchema = exports.beginAccountLoginResultSchema = exports.accountManagerResultSchema = exports.accountProviderIdSchema = exports.activeAccountStatusSchema = exports.activeProviderAccountStatusSchema = exports.quotaHistoryDailyBucketSchema = exports.quotaHistorySampleSchema = exports.quotaHistoryRuntimeProviderSchema = exports.providerQuotaMapSchema = exports.zaiProviderQuotaStateSchema = exports.codexProviderQuotaStateSchema = exports.claudeProviderQuotaStateSchema = exports.providerQuotaStateSchema = exports.runtimeQuotaProviderSchema = exports.quotaFailureDescriptorSchema = exports.peakHoursStateSchema = exports.codexResetCreditsSnapshotSchema = exports.codexResetCreditSchema = exports.quotaSourceSchema = exports.quotaProviderIdSchema = exports.quotaFailureKindSchema = exports.quotaStateSchema = exports.quotaWindowSchema = exports.sessionEvidenceRefV1Schema = exports.providerSessionAdapterV1Schema = exports.providerCapabilitiesV1Schema = exports.pendingUserRequestV1Schema = exports.observedValueV1Schema = exports.observedAgentSessionV1Schema = exports.observationProvenanceV1Schema = exports.canonicalSessionTranscriptSchema = exports.canonicalTranscriptMessageSchema = exports.canonicalToolCallSchema = exports.canonicalTranscriptBlockSchema = exports.transcriptSourceProvenanceSchema = exports.tokenEstimateSchema = exports.normalizedUsageCostSchema = exports.normalizedUsageSchema = exports.toolResultSessionEventSchema = exports.toolUseSessionEventSchema = exports.systemSessionEventSchema = exports.summarySessionEventSchema = exports.assistantSessionEventSchema = exports.userSessionEventSchema = exports.extractSessionEvents = exports.permissionModeSchema = exports.sessionEventSchema = exports.sessionMessageSchema = exports.messageUsageSchema = void 0;
+exports.assistantTurnToolRefSchema = exports.assistantTurnToolGroupStepSchema = exports.assistantTurnTimelineItemSchema = exports.assistantTurnSubagentStatusSchema = exports.assistantTurnSubagentSchema = exports.assistantTurnReasoningTimelineItemSchema = exports.assistantTurnProjectionSchema = exports.assistantTurnProcessStepSchema = exports.assistantTurnProcessSchema = exports.assistantTurnNarrationStepSchema = exports.assistantTurnEventTypeSchema = exports.assistantTurnEventSchema = exports.listAllAccountsResultSchema = exports.savedAccountProfileSchema = exports.accountEntrySchema = void 0;
 var sessionEvent_1 = require("./sessionEvent");
 Object.defineProperty(exports, "messageUsageSchema", { enumerable: true, get: function () { return sessionEvent_1.messageUsageSchema; } });
 Object.defineProperty(exports, "sessionMessageSchema", { enumerable: true, get: function () { return sessionEvent_1.sessionMessageSchema; } });
@@ -32,6 +32,7 @@ Object.defineProperty(exports, "normalizedUsageCostSchema", { enumerable: true,
 var tokenEstimation_1 = require("./tokenEstimation");
 Object.defineProperty(exports, "tokenEstimateSchema", { enumerable: true, get: function () { return tokenEstimation_1.tokenEstimateSchema; } });
 var transcript_1 = require("./transcript");
+Object.defineProperty(exports, "transcriptSourceProvenanceSchema", { enumerable: true, get: function () { return transcript_1.transcriptSourceProvenanceSchema; } });
 Object.defineProperty(exports, "canonicalTranscriptBlockSchema", { enumerable: true, get: function () { return transcript_1.canonicalTranscriptBlockSchema; } });
 Object.defineProperty(exports, "canonicalToolCallSchema", { enumerable: true, get: function () { return transcript_1.canonicalToolCallSchema; } });
 Object.defineProperty(exports, "canonicalTranscriptMessageSchema", { enumerable: true, get: function () { return transcript_1.canonicalTranscriptMessageSchema; } });

package/dist/schemas/sessionEvent.d.ts

@@ -61,7 +61,11 @@ export declare const permissionModeSchema: z.ZodEnum<{
 }>;
 export declare const userSessionEventSchema: z.ZodObject<{
     timestamp: z.ZodString;
+    entrypoint: z.ZodOptional<z.ZodString>;
+    isMeta: z.ZodOptional<z.ZodBoolean>;
     isSidechain: z.ZodOptional<z.ZodBoolean>;
+    cwd: z.ZodOptional<z.ZodString>;
+    gitBranch: z.ZodOptional<z.ZodString>;
     permissionMode: z.ZodOptional<z.ZodEnum<{
         default: "default";
         acceptEdits: "acceptEdits";
@@ -136,7 +140,11 @@ export declare const userSessionEventSchema: z.ZodObject<{
 }, z.core.$strip>;
 export declare const assistantSessionEventSchema: z.ZodObject<{
     timestamp: z.ZodString;
+    entrypoint: z.ZodOptional<z.ZodString>;
+    isMeta: z.ZodOptional<z.ZodBoolean>;
     isSidechain: z.ZodOptional<z.ZodBoolean>;
+    cwd: z.ZodOptional<z.ZodString>;
+    gitBranch: z.ZodOptional<z.ZodString>;
     permissionMode: z.ZodOptional<z.ZodEnum<{
         default: "default";
         acceptEdits: "acceptEdits";
@@ -212,7 +220,11 @@ export declare const assistantSessionEventSchema: z.ZodObject<{
 export declare const summarySessionEventSchema: z.ZodType<SummarySessionEvent>;
 export declare const systemSessionEventSchema: z.ZodObject<{
     timestamp: z.ZodString;
+    entrypoint: z.ZodOptional<z.ZodString>;
+    isMeta: z.ZodOptional<z.ZodBoolean>;
     isSidechain: z.ZodOptional<z.ZodBoolean>;
+    cwd: z.ZodOptional<z.ZodString>;
+    gitBranch: z.ZodOptional<z.ZodString>;
     permissionMode: z.ZodOptional<z.ZodEnum<{
         default: "default";
         acceptEdits: "acceptEdits";
@@ -291,7 +303,11 @@ export declare const toolUseSessionEventSchema: z.ZodObject<{
         input: z.ZodRecord<z.ZodString, z.ZodUnknown>;
     }, z.core.$strip>;
     timestamp: z.ZodString;
+    entrypoint: z.ZodOptional<z.ZodString>;
+    isMeta: z.ZodOptional<z.ZodBoolean>;
     isSidechain: z.ZodOptional<z.ZodBoolean>;
+    cwd: z.ZodOptional<z.ZodString>;
+    gitBranch: z.ZodOptional<z.ZodString>;
     permissionMode: z.ZodOptional<z.ZodEnum<{
         default: "default";
         acceptEdits: "acceptEdits";
@@ -371,7 +387,11 @@ export declare const toolResultSessionEventSchema: z.ZodObject<{
         is_error: z.ZodOptional<z.ZodBoolean>;
     }, z.core.$strip>;
     timestamp: z.ZodString;
+    entrypoint: z.ZodOptional<z.ZodString>;
+    isMeta: z.ZodOptional<z.ZodBoolean>;
     isSidechain: z.ZodOptional<z.ZodBoolean>;
+    cwd: z.ZodOptional<z.ZodString>;
+    gitBranch: z.ZodOptional<z.ZodString>;
     permissionMode: z.ZodOptional<z.ZodEnum<{
         default: "default";
         acceptEdits: "acceptEdits";

package/dist/schemas/sessionEvent.js

@@ -41,7 +41,11 @@ exports.permissionModeSchema = zod_1.z.enum([
 // ── SessionEvent ──
 const eventBaseShape = {
     timestamp: zod_1.z.string(),
+    entrypoint: zod_1.z.string().optional(),
+    isMeta: zod_1.z.boolean().optional(),
     isSidechain: zod_1.z.boolean().optional(),
+    cwd: zod_1.z.string().optional(),
+    gitBranch: zod_1.z.string().optional(),
     permissionMode: exports.permissionModeSchema.optional(),
     rateLimits: zod_1.z
         .object({
@@ -169,19 +173,38 @@ const MAX_PROGRESS_DEPTH = 8;
  * Returns zero events for unrecognized input — never throws.
  */
 function extractSessionEvents(raw, depth = 0) {
+    return extractSessionEventsWithProvenance(raw, depth, {});
+}
+function extractSessionEventsWithProvenance(raw, depth, inherited) {
     const direct = exports.sessionEventSchema.safeParse(raw);
     if (direct.success)
-        return [direct.data];
+        return [{ ...inherited, ...direct.data }];
     if (depth >= MAX_PROGRESS_DEPTH)
         return [];
     if (typeof raw === 'object' && raw !== null && raw.type === 'progress') {
+        const provenance = { ...inherited, ...progressProvenance(raw) };
         const data = raw.data;
         if (typeof data === 'object' && data !== null) {
             const message = data.message;
             if (typeof message === 'object' && message !== null) {
-                return extractSessionEvents(message, depth + 1);
+                return extractSessionEventsWithProvenance(message, depth + 1, provenance);
             }
         }
     }
     return [];
 }
+function progressProvenance(raw) {
+    const value = raw;
+    const provenance = {};
+    if (typeof value.entrypoint === 'string')
+        provenance.entrypoint = value.entrypoint;
+    if (typeof value.isMeta === 'boolean')
+        provenance.isMeta = value.isMeta;
+    if (typeof value.isSidechain === 'boolean')
+        provenance.isSidechain = value.isSidechain;
+    if (typeof value.cwd === 'string')
+        provenance.cwd = value.cwd;
+    if (typeof value.gitBranch === 'string')
+        provenance.gitBranch = value.gitBranch;
+    return provenance;
+}

package/dist/schemas/transcript.d.ts

@@ -1,5 +1,6 @@
 import { z } from 'zod';
-import type { CanonicalSessionTranscript, CanonicalTranscriptMessage, CanonicalToolCall } from '../transcript';
+import type { CanonicalSessionTranscript, CanonicalTranscriptMessage, CanonicalToolCall, TranscriptSourceProvenance } from '../transcript';
+export declare const transcriptSourceProvenanceSchema: z.ZodType<TranscriptSourceProvenance>;
 export declare const canonicalTranscriptBlockSchema: z.ZodObject<{
     type: z.ZodEnum<{
         unknown: "unknown";

package/dist/schemas/transcript.js

@@ -1,13 +1,17 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.canonicalSessionTranscriptSchema = exports.canonicalTranscriptMessageSchema = exports.canonicalToolCallSchema = exports.canonicalTranscriptBlockSchema = void 0;
+exports.canonicalSessionTranscriptSchema = exports.canonicalTranscriptMessageSchema = exports.canonicalToolCallSchema = exports.canonicalTranscriptBlockSchema = exports.transcriptSourceProvenanceSchema = void 0;
 const zod_1 = require("zod");
 const usageNormalization_1 = require("./usageNormalization");
-const transcriptSourceSchema = zod_1.z.object({
+exports.transcriptSourceProvenanceSchema = zod_1.z.object({
     provider: zod_1.z.string().optional(),
     sessionId: zod_1.z.string().optional(),
     sourcePath: zod_1.z.string().optional(),
     source: zod_1.z.string().optional(),
+    entrypoint: zod_1.z.string().optional(),
+    isMeta: zod_1.z.boolean().optional(),
+    isSidechain: zod_1.z.boolean().optional(),
+    originalRole: zod_1.z.string().optional(),
     eventIndex: zod_1.z.number().int().nonnegative(),
     eventType: zod_1.z.enum(['user', 'assistant', 'tool_use', 'tool_result', 'summary', 'system']),
     eventId: zod_1.z.string().optional(),
@@ -32,7 +36,7 @@ exports.canonicalToolCallSchema = zod_1.z.object({
     output: zod_1.z.unknown().optional(),
     isError: zod_1.z.boolean().optional(),
     command: zod_1.z.string().optional(),
-    source: transcriptSourceSchema,
+    source: exports.transcriptSourceProvenanceSchema,
 });
 exports.canonicalTranscriptMessageSchema = zod_1.z.object({
     id: zod_1.z.string().optional(),
@@ -46,12 +50,14 @@ exports.canonicalTranscriptMessageSchema = zod_1.z.object({
     cost: usageNormalization_1.normalizedUsageCostSchema.optional(),
     tools: zod_1.z.array(exports.canonicalToolCallSchema),
     commands: zod_1.z.array(zod_1.z.string()),
-    source: transcriptSourceSchema,
+    source: exports.transcriptSourceProvenanceSchema,
 });
 exports.canonicalSessionTranscriptSchema = zod_1.z.object({
     provider: zod_1.z.string().optional(),
     sessionId: zod_1.z.string().optional(),
     sourcePath: zod_1.z.string().optional(),
+    cwd: zod_1.z.string().optional(),
+    gitBranch: zod_1.z.string().optional(),
     startedAt: zod_1.z.string().optional(),
     endedAt: zod_1.z.string().optional(),
     models: zod_1.z.array(zod_1.z.string()),

package/dist/transcript.d.ts

@@ -7,6 +7,10 @@ export interface TranscriptSourceProvenance {
     sessionId?: string;
     sourcePath?: string;
     source?: string;
+    entrypoint?: string;
+    isMeta?: boolean;
+    isSidechain?: boolean;
+    originalRole?: string;
     eventIndex: number;
     eventType: SessionEvent['type'];
     eventId?: string;
@@ -61,6 +65,8 @@ export interface CanonicalSessionTranscript {
     provider?: ProviderId | string;
     sessionId?: string;
     sourcePath?: string;
+    cwd?: string;
+    gitBranch?: string;
     startedAt?: string;
     endedAt?: string;
     models: string[];