sidekick-shared 0.22.0 → 0.23.0

package/dist/schemas/observedSessionV1.d.ts

@@ -0,0 +1,499 @@
+import { z } from 'zod';
+export declare const observationProvenanceV1Schema: z.ZodEnum<{
+    reported: "reported";
+    estimated: "estimated";
+    inferred: "inferred";
+}>;
+export declare const sessionEvidenceRefV1Schema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<1>;
+    provider: z.ZodEnum<{
+        "claude-code": "claude-code";
+        codex: "codex";
+        opencode: "opencode";
+    }>;
+    sessionId: z.ZodString;
+    sourcePath: z.ZodOptional<z.ZodString>;
+    eventIndex: z.ZodOptional<z.ZodNumber>;
+    eventId: z.ZodOptional<z.ZodString>;
+    timestamp: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const observedValueV1Schema: <T extends z.ZodType>(value: T) => z.ZodObject<{
+    value: T;
+    provenance: z.ZodEnum<{
+        reported: "reported";
+        estimated: "estimated";
+        inferred: "inferred";
+    }>;
+    confidence: z.ZodNumber;
+    evidence: z.ZodArray<z.ZodObject<{
+        schemaVersion: z.ZodLiteral<1>;
+        provider: z.ZodEnum<{
+            "claude-code": "claude-code";
+            codex: "codex";
+            opencode: "opencode";
+        }>;
+        sessionId: z.ZodString;
+        sourcePath: z.ZodOptional<z.ZodString>;
+        eventIndex: z.ZodOptional<z.ZodNumber>;
+        eventId: z.ZodOptional<z.ZodString>;
+        timestamp: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export declare const pendingUserRequestV1Schema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<1>;
+    id: z.ZodString;
+    provider: z.ZodEnum<{
+        "claude-code": "claude-code";
+        codex: "codex";
+        opencode: "opencode";
+    }>;
+    sessionId: z.ZodString;
+    kind: z.ZodObject<{
+        value: z.ZodEnum<{
+            question: "question";
+            prompt_response: "prompt_response";
+            tool_approval: "tool_approval";
+        }>;
+        provenance: z.ZodEnum<{
+            reported: "reported";
+            estimated: "estimated";
+            inferred: "inferred";
+        }>;
+        confidence: z.ZodNumber;
+        evidence: z.ZodArray<z.ZodObject<{
+            schemaVersion: z.ZodLiteral<1>;
+            provider: z.ZodEnum<{
+                "claude-code": "claude-code";
+                codex: "codex";
+                opencode: "opencode";
+            }>;
+            sessionId: z.ZodString;
+            sourcePath: z.ZodOptional<z.ZodString>;
+            eventIndex: z.ZodOptional<z.ZodNumber>;
+            eventId: z.ZodOptional<z.ZodString>;
+            timestamp: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>;
+    requestedAt: z.ZodObject<{
+        value: z.ZodString;
+        provenance: z.ZodEnum<{
+            reported: "reported";
+            estimated: "estimated";
+            inferred: "inferred";
+        }>;
+        confidence: z.ZodNumber;
+        evidence: z.ZodArray<z.ZodObject<{
+            schemaVersion: z.ZodLiteral<1>;
+            provider: z.ZodEnum<{
+                "claude-code": "claude-code";
+                codex: "codex";
+                opencode: "opencode";
+            }>;
+            sessionId: z.ZodString;
+            sourcePath: z.ZodOptional<z.ZodString>;
+            eventIndex: z.ZodOptional<z.ZodNumber>;
+            eventId: z.ZodOptional<z.ZodString>;
+            timestamp: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>;
+    prompt: z.ZodObject<{
+        value: z.ZodNullable<z.ZodString>;
+        provenance: z.ZodEnum<{
+            reported: "reported";
+            estimated: "estimated";
+            inferred: "inferred";
+        }>;
+        confidence: z.ZodNumber;
+        evidence: z.ZodArray<z.ZodObject<{
+            schemaVersion: z.ZodLiteral<1>;
+            provider: z.ZodEnum<{
+                "claude-code": "claude-code";
+                codex: "codex";
+                opencode: "opencode";
+            }>;
+            sessionId: z.ZodString;
+            sourcePath: z.ZodOptional<z.ZodString>;
+            eventIndex: z.ZodOptional<z.ZodNumber>;
+            eventId: z.ZodOptional<z.ZodString>;
+            timestamp: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export declare const observedAgentSessionV1Schema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<1>;
+    identity: z.ZodObject<{
+        provider: z.ZodEnum<{
+            "claude-code": "claude-code";
+            codex: "codex";
+            opencode: "opencode";
+        }>;
+        sessionId: z.ZodString;
+        sourcePath: z.ZodString;
+    }, z.core.$strip>;
+    cwd: z.ZodObject<{
+        value: z.ZodString;
+        provenance: z.ZodEnum<{
+            reported: "reported";
+            estimated: "estimated";
+            inferred: "inferred";
+        }>;
+        confidence: z.ZodNumber;
+        evidence: z.ZodArray<z.ZodObject<{
+            schemaVersion: z.ZodLiteral<1>;
+            provider: z.ZodEnum<{
+                "claude-code": "claude-code";
+                codex: "codex";
+                opencode: "opencode";
+            }>;
+            sessionId: z.ZodString;
+            sourcePath: z.ZodOptional<z.ZodString>;
+            eventIndex: z.ZodOptional<z.ZodNumber>;
+            eventId: z.ZodOptional<z.ZodString>;
+            timestamp: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>;
+    model: z.ZodObject<{
+        value: z.ZodNullable<z.ZodString>;
+        provenance: z.ZodEnum<{
+            reported: "reported";
+            estimated: "estimated";
+            inferred: "inferred";
+        }>;
+        confidence: z.ZodNumber;
+        evidence: z.ZodArray<z.ZodObject<{
+            schemaVersion: z.ZodLiteral<1>;
+            provider: z.ZodEnum<{
+                "claude-code": "claude-code";
+                codex: "codex";
+                opencode: "opencode";
+            }>;
+            sessionId: z.ZodString;
+            sourcePath: z.ZodOptional<z.ZodString>;
+            eventIndex: z.ZodOptional<z.ZodNumber>;
+            eventId: z.ZodOptional<z.ZodString>;
+            timestamp: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>;
+    activity: z.ZodObject<{
+        value: z.ZodEnum<{
+            unknown: "unknown";
+            active: "active";
+            idle: "idle";
+            ended: "ended";
+        }>;
+        provenance: z.ZodEnum<{
+            reported: "reported";
+            estimated: "estimated";
+            inferred: "inferred";
+        }>;
+        confidence: z.ZodNumber;
+        evidence: z.ZodArray<z.ZodObject<{
+            schemaVersion: z.ZodLiteral<1>;
+            provider: z.ZodEnum<{
+                "claude-code": "claude-code";
+                codex: "codex";
+                opencode: "opencode";
+            }>;
+            sessionId: z.ZodString;
+            sourcePath: z.ZodOptional<z.ZodString>;
+            eventIndex: z.ZodOptional<z.ZodNumber>;
+            eventId: z.ZodOptional<z.ZodString>;
+            timestamp: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>;
+    usage: z.ZodObject<{
+        inputTokens: z.ZodObject<{
+            value: z.ZodNumber;
+            provenance: z.ZodEnum<{
+                reported: "reported";
+                estimated: "estimated";
+                inferred: "inferred";
+            }>;
+            confidence: z.ZodNumber;
+            evidence: z.ZodArray<z.ZodObject<{
+                schemaVersion: z.ZodLiteral<1>;
+                provider: z.ZodEnum<{
+                    "claude-code": "claude-code";
+                    codex: "codex";
+                    opencode: "opencode";
+                }>;
+                sessionId: z.ZodString;
+                sourcePath: z.ZodOptional<z.ZodString>;
+                eventIndex: z.ZodOptional<z.ZodNumber>;
+                eventId: z.ZodOptional<z.ZodString>;
+                timestamp: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>;
+        outputTokens: z.ZodObject<{
+            value: z.ZodNumber;
+            provenance: z.ZodEnum<{
+                reported: "reported";
+                estimated: "estimated";
+                inferred: "inferred";
+            }>;
+            confidence: z.ZodNumber;
+            evidence: z.ZodArray<z.ZodObject<{
+                schemaVersion: z.ZodLiteral<1>;
+                provider: z.ZodEnum<{
+                    "claude-code": "claude-code";
+                    codex: "codex";
+                    opencode: "opencode";
+                }>;
+                sessionId: z.ZodString;
+                sourcePath: z.ZodOptional<z.ZodString>;
+                eventIndex: z.ZodOptional<z.ZodNumber>;
+                eventId: z.ZodOptional<z.ZodString>;
+                timestamp: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>;
+        cacheReadTokens: z.ZodObject<{
+            value: z.ZodNumber;
+            provenance: z.ZodEnum<{
+                reported: "reported";
+                estimated: "estimated";
+                inferred: "inferred";
+            }>;
+            confidence: z.ZodNumber;
+            evidence: z.ZodArray<z.ZodObject<{
+                schemaVersion: z.ZodLiteral<1>;
+                provider: z.ZodEnum<{
+                    "claude-code": "claude-code";
+                    codex: "codex";
+                    opencode: "opencode";
+                }>;
+                sessionId: z.ZodString;
+                sourcePath: z.ZodOptional<z.ZodString>;
+                eventIndex: z.ZodOptional<z.ZodNumber>;
+                eventId: z.ZodOptional<z.ZodString>;
+                timestamp: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>;
+        cacheWriteTokens: z.ZodObject<{
+            value: z.ZodNumber;
+            provenance: z.ZodEnum<{
+                reported: "reported";
+                estimated: "estimated";
+                inferred: "inferred";
+            }>;
+            confidence: z.ZodNumber;
+            evidence: z.ZodArray<z.ZodObject<{
+                schemaVersion: z.ZodLiteral<1>;
+                provider: z.ZodEnum<{
+                    "claude-code": "claude-code";
+                    codex: "codex";
+                    opencode: "opencode";
+                }>;
+                sessionId: z.ZodString;
+                sourcePath: z.ZodOptional<z.ZodString>;
+                eventIndex: z.ZodOptional<z.ZodNumber>;
+                eventId: z.ZodOptional<z.ZodString>;
+                timestamp: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>;
+        costUsd: z.ZodObject<{
+            value: z.ZodNumber;
+            provenance: z.ZodEnum<{
+                reported: "reported";
+                estimated: "estimated";
+                inferred: "inferred";
+            }>;
+            confidence: z.ZodNumber;
+            evidence: z.ZodArray<z.ZodObject<{
+                schemaVersion: z.ZodLiteral<1>;
+                provider: z.ZodEnum<{
+                    "claude-code": "claude-code";
+                    codex: "codex";
+                    opencode: "opencode";
+                }>;
+                sessionId: z.ZodString;
+                sourcePath: z.ZodOptional<z.ZodString>;
+                eventIndex: z.ZodOptional<z.ZodNumber>;
+                eventId: z.ZodOptional<z.ZodString>;
+                timestamp: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>;
+    }, z.core.$strip>;
+    pendingUserRequest: z.ZodNullable<z.ZodObject<{
+        schemaVersion: z.ZodLiteral<1>;
+        id: z.ZodString;
+        provider: z.ZodEnum<{
+            "claude-code": "claude-code";
+            codex: "codex";
+            opencode: "opencode";
+        }>;
+        sessionId: z.ZodString;
+        kind: z.ZodObject<{
+            value: z.ZodEnum<{
+                question: "question";
+                prompt_response: "prompt_response";
+                tool_approval: "tool_approval";
+            }>;
+            provenance: z.ZodEnum<{
+                reported: "reported";
+                estimated: "estimated";
+                inferred: "inferred";
+            }>;
+            confidence: z.ZodNumber;
+            evidence: z.ZodArray<z.ZodObject<{
+                schemaVersion: z.ZodLiteral<1>;
+                provider: z.ZodEnum<{
+                    "claude-code": "claude-code";
+                    codex: "codex";
+                    opencode: "opencode";
+                }>;
+                sessionId: z.ZodString;
+                sourcePath: z.ZodOptional<z.ZodString>;
+                eventIndex: z.ZodOptional<z.ZodNumber>;
+                eventId: z.ZodOptional<z.ZodString>;
+                timestamp: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>;
+        requestedAt: z.ZodObject<{
+            value: z.ZodString;
+            provenance: z.ZodEnum<{
+                reported: "reported";
+                estimated: "estimated";
+                inferred: "inferred";
+            }>;
+            confidence: z.ZodNumber;
+            evidence: z.ZodArray<z.ZodObject<{
+                schemaVersion: z.ZodLiteral<1>;
+                provider: z.ZodEnum<{
+                    "claude-code": "claude-code";
+                    codex: "codex";
+                    opencode: "opencode";
+                }>;
+                sessionId: z.ZodString;
+                sourcePath: z.ZodOptional<z.ZodString>;
+                eventIndex: z.ZodOptional<z.ZodNumber>;
+                eventId: z.ZodOptional<z.ZodString>;
+                timestamp: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>;
+        prompt: z.ZodObject<{
+            value: z.ZodNullable<z.ZodString>;
+            provenance: z.ZodEnum<{
+                reported: "reported";
+                estimated: "estimated";
+                inferred: "inferred";
+            }>;
+            confidence: z.ZodNumber;
+            evidence: z.ZodArray<z.ZodObject<{
+                schemaVersion: z.ZodLiteral<1>;
+                provider: z.ZodEnum<{
+                    "claude-code": "claude-code";
+                    codex: "codex";
+                    opencode: "opencode";
+                }>;
+                sessionId: z.ZodString;
+                sourcePath: z.ZodOptional<z.ZodString>;
+                eventIndex: z.ZodOptional<z.ZodNumber>;
+                eventId: z.ZodOptional<z.ZodString>;
+                timestamp: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>;
+    }, z.core.$strip>>;
+    observedAt: z.ZodString;
+}, z.core.$strip>;
+export declare const providerCapabilitiesV1Schema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<1>;
+    provider: z.ZodEnum<{
+        "claude-code": "claude-code";
+        codex: "codex";
+        opencode: "opencode";
+    }>;
+    resume: z.ZodObject<{
+        value: z.ZodBoolean;
+        provenance: z.ZodEnum<{
+            reported: "reported";
+            estimated: "estimated";
+            inferred: "inferred";
+        }>;
+        confidence: z.ZodNumber;
+        evidence: z.ZodArray<z.ZodObject<{
+            schemaVersion: z.ZodLiteral<1>;
+            provider: z.ZodEnum<{
+                "claude-code": "claude-code";
+                codex: "codex";
+                opencode: "opencode";
+            }>;
+            sessionId: z.ZodString;
+            sourcePath: z.ZodOptional<z.ZodString>;
+            eventIndex: z.ZodOptional<z.ZodNumber>;
+            eventId: z.ZodOptional<z.ZodString>;
+            timestamp: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>;
+    forkLineage: z.ZodObject<{
+        value: z.ZodBoolean;
+        provenance: z.ZodEnum<{
+            reported: "reported";
+            estimated: "estimated";
+            inferred: "inferred";
+        }>;
+        confidence: z.ZodNumber;
+        evidence: z.ZodArray<z.ZodObject<{
+            schemaVersion: z.ZodLiteral<1>;
+            provider: z.ZodEnum<{
+                "claude-code": "claude-code";
+                codex: "codex";
+                opencode: "opencode";
+            }>;
+            sessionId: z.ZodString;
+            sourcePath: z.ZodOptional<z.ZodString>;
+            eventIndex: z.ZodOptional<z.ZodNumber>;
+            eventId: z.ZodOptional<z.ZodString>;
+            timestamp: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>;
+    quotaSource: z.ZodObject<{
+        value: z.ZodEnum<{
+            none: "none";
+            api: "api";
+            session: "session";
+            mixed: "mixed";
+        }>;
+        provenance: z.ZodEnum<{
+            reported: "reported";
+            estimated: "estimated";
+            inferred: "inferred";
+        }>;
+        confidence: z.ZodNumber;
+        evidence: z.ZodArray<z.ZodObject<{
+            schemaVersion: z.ZodLiteral<1>;
+            provider: z.ZodEnum<{
+                "claude-code": "claude-code";
+                codex: "codex";
+                opencode: "opencode";
+            }>;
+            sessionId: z.ZodString;
+            sourcePath: z.ZodOptional<z.ZodString>;
+            eventIndex: z.ZodOptional<z.ZodNumber>;
+            eventId: z.ZodOptional<z.ZodString>;
+            timestamp: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>;
+    assetExtraction: z.ZodObject<{
+        value: z.ZodBoolean;
+        provenance: z.ZodEnum<{
+            reported: "reported";
+            estimated: "estimated";
+            inferred: "inferred";
+        }>;
+        confidence: z.ZodNumber;
+        evidence: z.ZodArray<z.ZodObject<{
+            schemaVersion: z.ZodLiteral<1>;
+            provider: z.ZodEnum<{
+                "claude-code": "claude-code";
+                codex: "codex";
+                opencode: "opencode";
+            }>;
+            sessionId: z.ZodString;
+            sourcePath: z.ZodOptional<z.ZodString>;
+            eventIndex: z.ZodOptional<z.ZodNumber>;
+            eventId: z.ZodOptional<z.ZodString>;
+            timestamp: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export declare const providerSessionAdapterV1Schema: z.ZodCustom<import("../types/observedSessionV1").ProviderSessionAdapterV1, import("../types/observedSessionV1").ProviderSessionAdapterV1>;

package/dist/schemas/observedSessionV1.js

@@ -0,0 +1,69 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.providerSessionAdapterV1Schema = exports.providerCapabilitiesV1Schema = exports.observedAgentSessionV1Schema = exports.pendingUserRequestV1Schema = exports.observedValueV1Schema = exports.sessionEvidenceRefV1Schema = exports.observationProvenanceV1Schema = void 0;
+const zod_1 = require("zod");
+exports.observationProvenanceV1Schema = zod_1.z.enum(['reported', 'estimated', 'inferred']);
+exports.sessionEvidenceRefV1Schema = zod_1.z.object({
+    schemaVersion: zod_1.z.literal(1),
+    provider: zod_1.z.enum(['claude-code', 'opencode', 'codex']),
+    sessionId: zod_1.z.string().min(1),
+    sourcePath: zod_1.z.string().optional(),
+    eventIndex: zod_1.z.number().int().nonnegative().optional(),
+    eventId: zod_1.z.string().optional(),
+    timestamp: zod_1.z.string().optional(),
+});
+const observedValueV1Schema = (value) => zod_1.z.object({
+    value,
+    provenance: exports.observationProvenanceV1Schema,
+    confidence: zod_1.z.number().min(0).max(1),
+    evidence: zod_1.z.array(exports.sessionEvidenceRefV1Schema),
+});
+exports.observedValueV1Schema = observedValueV1Schema;
+exports.pendingUserRequestV1Schema = zod_1.z.object({
+    schemaVersion: zod_1.z.literal(1),
+    id: zod_1.z.string().min(1),
+    provider: zod_1.z.enum(['claude-code', 'opencode', 'codex']),
+    sessionId: zod_1.z.string().min(1),
+    kind: (0, exports.observedValueV1Schema)(zod_1.z.enum(['prompt_response', 'tool_approval', 'question'])),
+    requestedAt: (0, exports.observedValueV1Schema)(zod_1.z.string()),
+    prompt: (0, exports.observedValueV1Schema)(zod_1.z.string().nullable()),
+});
+exports.observedAgentSessionV1Schema = zod_1.z.object({
+    schemaVersion: zod_1.z.literal(1),
+    identity: zod_1.z.object({
+        provider: zod_1.z.enum(['claude-code', 'opencode', 'codex']),
+        sessionId: zod_1.z.string().min(1),
+        sourcePath: zod_1.z.string(),
+    }),
+    cwd: (0, exports.observedValueV1Schema)(zod_1.z.string()),
+    model: (0, exports.observedValueV1Schema)(zod_1.z.string().nullable()),
+    activity: (0, exports.observedValueV1Schema)(zod_1.z.enum(['active', 'idle', 'ended', 'unknown'])),
+    usage: zod_1.z.object({
+        inputTokens: (0, exports.observedValueV1Schema)(zod_1.z.number().nonnegative()),
+        outputTokens: (0, exports.observedValueV1Schema)(zod_1.z.number().nonnegative()),
+        cacheReadTokens: (0, exports.observedValueV1Schema)(zod_1.z.number().nonnegative()),
+        cacheWriteTokens: (0, exports.observedValueV1Schema)(zod_1.z.number().nonnegative()),
+        costUsd: (0, exports.observedValueV1Schema)(zod_1.z.number().nonnegative()),
+    }),
+    pendingUserRequest: exports.pendingUserRequestV1Schema.nullable(),
+    observedAt: zod_1.z.string(),
+});
+exports.providerCapabilitiesV1Schema = zod_1.z.object({
+    schemaVersion: zod_1.z.literal(1),
+    provider: zod_1.z.enum(['claude-code', 'opencode', 'codex']),
+    resume: (0, exports.observedValueV1Schema)(zod_1.z.boolean()),
+    forkLineage: (0, exports.observedValueV1Schema)(zod_1.z.boolean()),
+    quotaSource: (0, exports.observedValueV1Schema)(zod_1.z.enum(['api', 'session', 'mixed', 'none'])),
+    assetExtraction: (0, exports.observedValueV1Schema)(zod_1.z.boolean()),
+});
+exports.providerSessionAdapterV1Schema = zod_1.z.custom((value) => {
+    if (!value || typeof value !== 'object')
+        return false;
+    const adapter = value;
+    return (adapter.schemaVersion === 1 &&
+        typeof adapter.discover === 'function' &&
+        typeof adapter.read === 'function' &&
+        typeof adapter.watch === 'function' &&
+        typeof adapter.dispose === 'function' &&
+        exports.providerCapabilitiesV1Schema.safeParse(adapter.capabilities).success);
+}, { message: 'Invalid ProviderSessionAdapterV1 contract' });

package/dist/schemas/sessionEvent.d.ts

@@ -81,6 +81,19 @@ export declare const sessionEventSchema: z.ZodObject<{
             resetsAt: z.ZodNumber;
         }, z.core.$strip>>;
     }, z.core.$strip>>;
+    compaction: z.ZodOptional<z.ZodObject<{
+        tokensBefore: z.ZodNumber;
+        tokensAfter: z.ZodNumber;
+    }, z.core.$strip>>;
+    providerMetadata: z.ZodOptional<z.ZodObject<{
+        retryAttempts: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
+        finishReasons: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        providerError: z.ZodOptional<z.ZodObject<{
+            type: z.ZodOptional<z.ZodString>;
+            message: z.ZodOptional<z.ZodString>;
+            code: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
     tool: z.ZodOptional<z.ZodObject<{
         name: z.ZodString;
         input: z.ZodRecord<z.ZodString, z.ZodUnknown>;

package/dist/schemas/sessionEvent.js

@@ -61,6 +61,25 @@ exports.sessionEventSchema = zod_1.z.object({
             .optional(),
     })
         .optional(),
+    compaction: zod_1.z
+        .object({
+        tokensBefore: zod_1.z.number().nonnegative(),
+        tokensAfter: zod_1.z.number().nonnegative(),
+    })
+        .optional(),
+    providerMetadata: zod_1.z
+        .object({
+        retryAttempts: zod_1.z.array(zod_1.z.number()).optional(),
+        finishReasons: zod_1.z.array(zod_1.z.string()).optional(),
+        providerError: zod_1.z
+            .object({
+            type: zod_1.z.string().optional(),
+            message: zod_1.z.string().optional(),
+            code: zod_1.z.union([zod_1.z.string(), zod_1.z.number()]).optional(),
+        })
+            .optional(),
+    })
+        .optional(),
     tool: zod_1.z
         .object({
         name: zod_1.z.string(),

package/dist/search/sessionSearch.d.ts

@@ -1,7 +1,7 @@
 /**
  * Provider-aware cross-session search.
  */
-import type { SessionProvider, ProviderId } from '../providers/types';
+import type { SessionProviderBase, ProviderId } from '../providers/types';
 export interface SearchResult {
     providerId: ProviderId;
     projectPath: string;
@@ -10,7 +10,7 @@ export interface SearchResult {
     eventType: string;
     timestamp: string;
 }
-export declare function searchSessions(provider: SessionProvider, query: string, opts?: {
+export declare function searchSessions(provider: SessionProviderBase, query: string, opts?: {
     projectSlug?: string;
     maxResults?: number;
 }): Promise<SearchResult[]>;

package/dist/search/sessionSearch.js

@@ -70,9 +70,8 @@ async function searchSessions(provider, query, opts) {
             }
             // If no files found from dir scan, try findAllSessions with the folder name
             if (sessionFiles.length === 0) {
-                // Use provider.findSessionFiles with the folder path as workspace
-                // This handles DB-backed providers
-                sessionFiles = provider.findSessionFiles(folder.name);
+                // Let canonical directory discovery handle synthetic DB-backed paths.
+                sessionFiles = provider.findSessionsInDirectory(folder.dir);
             }
             for (const sessionPath of sessionFiles) {
                 if (results.length >= maxResults)

package/dist/sessionMonitor.d.ts

@@ -0,0 +1,29 @@
+import type { AggregatedMetrics, EventAggregatorOptions } from './aggregation/types';
+import type { SessionProviderBase } from './providers/types';
+import type { SessionEvent } from './types/sessionEvent';
+export interface SessionMonitorOptions extends EventAggregatorOptions {
+    replayOnAttach?: boolean;
+}
+/**
+ * UI-independent session monitor for library consumers. It owns one provider
+ * reader and the canonical aggregator; hosts decide how often to call `poll()`.
+ */
+export declare class SessionMonitor {
+    private readonly provider;
+    private readonly aggregator;
+    private reader;
+    private sessionPath;
+    private readonly listeners;
+    private readonly replayOnAttach;
+    constructor(provider: SessionProviderBase, options?: SessionMonitorOptions);
+    attach(sessionPath: string, replay?: boolean): AggregatedMetrics;
+    attachLatest(workspacePath: string, replay?: boolean): AggregatedMetrics | null;
+    poll(): SessionEvent[];
+    process(event: SessionEvent): void;
+    onEvent(listener: (event: SessionEvent) => void): () => void;
+    getMetrics(): AggregatedMetrics;
+    getSessionPath(): string | null;
+    reset(): void;
+    dispose(): void;
+    private consume;
+}