sidekick-shared 0.26.6 → 0.27.0

package/dist/promptHistory.js

@@ -0,0 +1,616 @@
+"use strict";
+/**
+ * Node-only collection of human-typed prompts from Claude Code and Codex
+ * session logs, scoped to a set of workspace roots.
+ *
+ * Parse-only: no redaction and no network I/O. Scope fails closed — a prompt
+ * is returned only when the working directory recorded on its log line (or,
+ * for Codex, its session/turn context) realpath-resolves to an allowed root
+ * or somewhere inside one. Every bound stops cleanly and is reported in
+ * `boundsHit`; nothing is silently truncated and no bound throws.
+ */
+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.collectPromptHistory = collectPromptHistory;
+const crypto_1 = require("crypto");
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const humanPrompt_1 = require("./humanPrompt");
+const sessionPathResolver_1 = require("./parsers/sessionPathResolver");
+const claudeCode_1 = require("./providers/claudeCode");
+const codex_1 = require("./providers/codex");
+const DEFAULT_BOUNDS = {
+    maxSessions: 1000,
+    maxFileBytes: 16 * 1024 * 1024,
+    maxTotalBytes: 256 * 1024 * 1024,
+    deadlineMs: 30_000,
+};
+const CHECK_EVERY_LINES = 500;
+const ALL_PROVIDERS = ['claude-code', 'codex'];
+/** Collect human-typed prompts from Claude Code and Codex logs under the given roots. */
+async function collectPromptHistory(options) {
+    const bounds = { ...DEFAULT_BOUNDS, ...definedBounds(options.bounds) };
+    const startedAt = Date.now();
+    const boundsHit = new Set();
+    const stats = {
+        sessionsScanned: 0,
+        sessionsSkippedUnchanged: 0,
+        sessionsOutOfScope: 0,
+        filesOverSizeLimit: 0,
+        sessionsNotInteractive: 0,
+        promptsMissingTimestamp: 0,
+        promptsOutOfScope: 0,
+    };
+    const previous = options.cursor?.version === 1 ? options.cursor.sessions : {};
+    const cursor = { version: 1, sessions: { ...previous } };
+    const entries = [];
+    const shouldStop = () => {
+        if (options.signal?.aborted)
+            return 'aborted';
+        if (Date.now() - startedAt >= bounds.deadlineMs)
+            return 'deadline';
+        return null;
+    };
+    const finish = () => ({
+        entries: entries.sort(compareEntries),
+        cursor,
+        stats,
+        boundsHit: [...boundsHit],
+    });
+    const realpaths = new Map();
+    const { roots, listingRoots } = resolveRoots(options.workspacePaths, options.includeWorktrees !== false, realpaths);
+    if (roots.length === 0)
+        return finish();
+    const sinceMs = options.since ? options.since.getTime() : null;
+    const providers = options.providers ?? ALL_PROVIDERS;
+    const candidates = await listCandidates(providers, listingRoots, sinceMs);
+    const context = { roots, sinceMs, stats, realpaths, shouldStop };
+    let totalBytes = 0;
+    for (const candidate of candidates) {
+        const stop = shouldStop();
+        if (stop) {
+            boundsHit.add(stop);
+            break;
+        }
+        let stat;
+        try {
+            stat = await fs.promises.stat(candidate.filePath);
+        }
+        catch {
+            continue;
+        }
+        const prior = previous[candidate.key];
+        if (prior && prior.size === stat.size && prior.mtimeMs === stat.mtimeMs) {
+            stats.sessionsSkippedUnchanged++;
+            continue;
+        }
+        // A file that shrank was rewritten; its old offsets and ordinals are meaningless.
+        const resume = prior && prior.offset <= stat.size ? prior : undefined;
+        const offset = resume?.offset ?? 0;
+        const bytesToRead = stat.size - offset;
+        if (resume?.state?.excluded) {
+            cursor.sessions[candidate.key] = {
+                ...resume,
+                size: stat.size,
+                mtimeMs: stat.mtimeMs,
+                offset: stat.size,
+            };
+            stats.sessionsNotInteractive++;
+            continue;
+        }
+        if (bytesToRead > bounds.maxFileBytes) {
+            stats.filesOverSizeLimit++;
+            boundsHit.add('maxFileBytes');
+            continue;
+        }
+        if (stats.sessionsScanned >= bounds.maxSessions) {
+            boundsHit.add('maxSessions');
+            break;
+        }
+        if (totalBytes + bytesToRead > bounds.maxTotalBytes) {
+            boundsHit.add('maxTotalBytes');
+            break;
+        }
+        let buffer;
+        try {
+            buffer = await readRange(candidate.filePath, offset, bytesToRead);
+        }
+        catch {
+            continue;
+        }
+        totalBytes += buffer.length;
+        stats.sessionsScanned++;
+        const outcome = await scanBuffer(candidate, buffer, offset, resume, context);
+        if (outcome.stoppedBy) {
+            // Partially processed file: drop its entries and leave its cursor untouched.
+            boundsHit.add(outcome.stoppedBy);
+            break;
+        }
+        if (outcome.notInteractive)
+            stats.sessionsNotInteractive++;
+        else if (outcome.inScope === 0 && outcome.outOfScope > 0)
+            stats.sessionsOutOfScope++;
+        entries.push(...outcome.entries);
+        cursor.sessions[candidate.key] = {
+            provider: candidate.provider,
+            sessionId: candidate.sessionId,
+            size: stat.size,
+            mtimeMs: stat.mtimeMs,
+            lastOrdinal: outcome.lastOrdinal,
+            offset: outcome.offset,
+            ...(outcome.state ? { state: outcome.state } : {}),
+        };
+        await yieldToEventLoop();
+    }
+    return finish();
+}
+function definedBounds(bounds) {
+    const result = {};
+    if (!bounds)
+        return result;
+    for (const key of Object.keys(DEFAULT_BOUNDS)) {
+        const value = bounds[key];
+        if (typeof value === 'number' && !Number.isNaN(value))
+            result[key] = Math.max(0, value);
+    }
+    return result;
+}
+function compareEntries(left, right) {
+    return (compareStrings(left.provider, right.provider) ||
+        compareStrings(left.sessionId, right.sessionId) ||
+        left.ordinal - right.ordinal);
+}
+function compareStrings(left, right) {
+    return left < right ? -1 : left > right ? 1 : 0;
+}
+function realpathOrNull(input, cache) {
+    const cached = cache.get(input);
+    if (cached !== undefined)
+        return cached;
+    let resolved = null;
+    try {
+        resolved = path.isAbsolute(input) ? fs.realpathSync.native(input) : null;
+    }
+    catch {
+        resolved = null;
+    }
+    cache.set(input, resolved);
+    return resolved;
+}
+function resolveRoots(workspacePaths, includeWorktrees, realpaths) {
+    const roots = new Set();
+    const listingRoots = new Set();
+    const add = (candidate) => {
+        const real = realpathOrNull(candidate, realpaths);
+        if (!real)
+            return;
+        roots.add(real);
+        listingRoots.add(real);
+        listingRoots.add(path.resolve(candidate));
+    };
+    for (const workspacePath of workspacePaths) {
+        if (typeof workspacePath !== 'string' || !path.isAbsolute(workspacePath))
+            continue;
+        add(workspacePath);
+        if (!includeWorktrees)
+            continue;
+        const real = realpathOrNull(workspacePath, realpaths);
+        if (!real)
+            continue;
+        const mainRepo = (0, sessionPathResolver_1.resolveWorktreeMainRepo)(real) ?? real;
+        add(mainRepo);
+        for (const sibling of (0, sessionPathResolver_1.discoverWorktreeSiblings)(mainRepo))
+            add(sibling);
+    }
+    return { roots: [...roots], listingRoots: [...listingRoots] };
+}
+/** Fail-closed scope check on a recorded working directory. */
+function scopedCwd(cwd, roots, realpaths) {
+    if (typeof cwd !== 'string' || cwd.length === 0)
+        return null;
+    const real = realpathOrNull(cwd, realpaths);
+    if (!real)
+        return null;
+    for (const root of roots) {
+        if (real === root)
+            return real;
+        const prefix = root.endsWith(path.sep) ? root : root + path.sep;
+        if (real.startsWith(prefix))
+            return real;
+    }
+    return null;
+}
+async function listCandidates(providers, listingRoots, sinceMs) {
+    const byPath = new Map();
+    const listOptions = sinceMs !== null ? { since: sinceMs } : {};
+    for (const provider of [...new Set(providers)]) {
+        if (!ALL_PROVIDERS.includes(provider))
+            continue;
+        // Listings are only candidate supersets; scope is re-checked per prompt.
+        const source = provider === 'claude-code' ? new claudeCode_1.ClaudeCodeProvider() : new codex_1.CodexProvider();
+        for (const root of listingRoots) {
+            let files;
+            try {
+                files = (await source.listSessionFilesAsync?.(root, listOptions)) ?? [];
+            }
+            catch {
+                files = [];
+            }
+            for (const file of files) {
+                if (byPath.has(file.path))
+                    continue;
+                const sessionId = file.sessionId ?? path.basename(file.path, '.jsonl');
+                byPath.set(file.path, {
+                    provider,
+                    sessionId,
+                    filePath: file.path,
+                    key: `${provider}:${sessionId}:${hashPath(file.path)}`,
+                });
+            }
+        }
+        source.dispose();
+    }
+    return [...byPath.values()].sort((left, right) => compareStrings(left.provider, right.provider) ||
+        compareStrings(left.sessionId, right.sessionId) ||
+        compareStrings(left.key, right.key));
+}
+function hashPath(filePath) {
+    return (0, crypto_1.createHash)('sha256').update(filePath).digest('hex').slice(0, 12);
+}
+async function readRange(filePath, offset, length) {
+    const buffer = Buffer.alloc(length);
+    if (length === 0)
+        return buffer;
+    const handle = await fs.promises.open(filePath, 'r');
+    try {
+        let read = 0;
+        while (read < length) {
+            const { bytesRead } = await handle.read(buffer, read, length - read, offset + read);
+            if (bytesRead === 0)
+                break;
+            read += bytesRead;
+        }
+        return read === length ? buffer : buffer.subarray(0, read);
+    }
+    finally {
+        await handle.close();
+    }
+}
+function yieldToEventLoop() {
+    return new Promise((resolve) => setImmediate(resolve));
+}
+async function scanBuffer(candidate, buffer, startOffset, resume, context) {
+    const lastNewline = buffer.lastIndexOf(0x0a);
+    const complete = lastNewline >= 0 ? buffer.subarray(0, lastNewline + 1) : Buffer.alloc(0);
+    const lines = complete.toString('utf8').split('\n');
+    const scanner = candidate.provider === 'claude-code'
+        ? new ClaudeLineScanner(candidate, resume, context)
+        : new CodexLineScanner(candidate, resume, context);
+    for (let index = 0; index < lines.length; index++) {
+        if (index > 0 && index % CHECK_EVERY_LINES === 0) {
+            await yieldToEventLoop();
+            const stop = context.shouldStop();
+            if (stop)
+                return { ...scanner.outcome(startOffset), stoppedBy: stop };
+        }
+        const line = lines[index];
+        if (!line.trim())
+            continue;
+        let record;
+        try {
+            record = JSON.parse(line);
+        }
+        catch {
+            continue;
+        }
+        if (typeof record !== 'object' || record === null)
+            continue;
+        if (scanner.accept(record) === 'excluded') {
+            // Non-interactive Codex session: nothing in it will ever count.
+            return {
+                ...scanner.outcome(startOffset + buffer.length),
+                entries: [],
+                notInteractive: true,
+                stoppedBy: null,
+            };
+        }
+    }
+    return { ...scanner.outcome(startOffset + complete.length), stoppedBy: null };
+}
+/** Shared per-file prompt bookkeeping for both providers. */
+class LineScanner {
+    candidate;
+    context;
+    entries = [];
+    nextOrdinal;
+    inScope = 0;
+    outOfScope = 0;
+    pending = null;
+    constructor(candidate, resume, context) {
+        this.candidate = candidate;
+        this.context = context;
+        this.nextOrdinal = (resume?.lastOrdinal ?? -1) + 1;
+    }
+    state() {
+        return undefined;
+    }
+    outcome(offset) {
+        const state = this.state();
+        return {
+            entries: this.entries,
+            lastOrdinal: this.nextOrdinal - 1,
+            offset,
+            ...(state ? { state } : {}),
+            inScope: this.inScope,
+            outOfScope: this.outOfScope,
+            notInteractive: false,
+        };
+    }
+    /** Assign an ordinal to a human prompt and emit it when in scope. */
+    recordPrompt(text, timestamp, cwd, gitBranch) {
+        const ordinal = this.nextOrdinal++;
+        this.pending = null;
+        if (typeof timestamp !== 'string' || Number.isNaN(Date.parse(timestamp))) {
+            this.context.stats.promptsMissingTimestamp++;
+            return;
+        }
+        const scoped = scopedCwd(cwd, this.context.roots, this.context.realpaths);
+        if (!scoped) {
+            this.outOfScope++;
+            this.context.stats.promptsOutOfScope++;
+            return;
+        }
+        this.inScope++;
+        if (this.context.sinceMs !== null && Date.parse(timestamp) < this.context.sinceMs)
+            return;
+        const entry = {
+            provider: this.candidate.provider,
+            sessionId: this.candidate.sessionId,
+            ordinal,
+            timestamp,
+            text,
+            cwd: scoped,
+            ...(gitBranch ? { gitBranch } : {}),
+        };
+        this.entries.push(entry);
+        this.pending = entry;
+    }
+}
+function transcriptMessage(candidate, record, role, content, extra, eventIndex) {
+    return {
+        role: 'user',
+        timestamp: typeof record.timestamp === 'string' ? record.timestamp : '',
+        content,
+        text: content
+            .filter((block) => block.type === 'text')
+            .map((block) => block.text ?? '')
+            .join('\n'),
+        tools: [],
+        commands: [],
+        source: {
+            provider: candidate.provider,
+            sessionId: candidate.sessionId,
+            originalRole: role,
+            eventIndex,
+            eventType: 'user',
+            ...extra,
+        },
+    };
+}
+function stringField(value) {
+    return typeof value === 'string' && value.length > 0 ? value : undefined;
+}
+function tokenCount(value) {
+    return typeof value === 'number' && Number.isFinite(value) && value >= 0 ? value : undefined;
+}
+function compactUsage(usage) {
+    const result = {};
+    for (const [key, value] of Object.entries(usage)) {
+        if (typeof value === 'number')
+            result[key] = value;
+    }
+    return Object.keys(result).length > 0 ? result : undefined;
+}
+class ClaudeLineScanner extends LineScanner {
+    lineIndex = 0;
+    answerId = null;
+    accept(record) {
+        const index = this.lineIndex++;
+        const message = record.message;
+        if (typeof message !== 'object' || message === null)
+            return 'ok';
+        if (record.type === 'user') {
+            const origin = record.origin;
+            const canonical = transcriptMessage(this.candidate, record, typeof message.role === 'string' ? message.role : 'user', claudeBlocks(message.content), {
+                entrypoint: stringField(record.entrypoint),
+                isMeta: record.isMeta === true ? true : undefined,
+                isSidechain: record.isSidechain === true ? true : undefined,
+                isCompactSummary: record.isCompactSummary === true ? true : undefined,
+                originKind: origin && typeof origin.kind === 'string' ? origin.kind : undefined,
+                promptSource: stringField(record.promptSource),
+            }, index);
+            const text = (0, humanPrompt_1.humanPromptText)(canonical, 'claude-code');
+            if (text === null)
+                return 'ok';
+            this.answerId = null;
+            this.recordPrompt(text, record.timestamp, record.cwd, stringField(record.gitBranch));
+            return 'ok';
+        }
+        if (record.type === 'assistant' && this.pending && record.isSidechain !== true) {
+            const id = stringField(message.id) ?? `line:${index}`;
+            if (this.answerId === null)
+                this.answerId = id;
+            if (id !== this.answerId) {
+                this.pending = null;
+                return 'ok';
+            }
+            const model = stringField(message.model);
+            if (model && model !== '<synthetic>')
+                this.pending.model = model;
+            const usage = message.usage;
+            if (usage && typeof usage === 'object') {
+                const mapped = compactUsage({
+                    inputTokens: tokenCount(usage.input_tokens),
+                    outputTokens: tokenCount(usage.output_tokens),
+                    cacheReadTokens: tokenCount(usage.cache_read_input_tokens),
+                    cacheWriteTokens: tokenCount(usage.cache_creation_input_tokens),
+                });
+                if (mapped)
+                    this.pending.usage = mapped;
+            }
+        }
+        return 'ok';
+    }
+}
+function claudeBlocks(content) {
+    if (typeof content === 'string')
+        return [{ type: 'text', text: content }];
+    if (!Array.isArray(content))
+        return [];
+    const blocks = [];
+    for (const item of content) {
+        if (typeof item !== 'object' || item === null)
+            continue;
+        const block = item;
+        if (block.type === 'text' && typeof block.text === 'string') {
+            blocks.push({ type: 'text', text: block.text });
+        }
+        else if (block.type === 'tool_result') {
+            blocks.push({ type: 'tool_result' });
+        }
+        else if (block.type === 'image') {
+            blocks.push({ type: 'image' });
+        }
+        else {
+            blocks.push({ type: 'unknown' });
+        }
+    }
+    return blocks;
+}
+class CodexLineScanner extends LineScanner {
+    lineIndex = 0;
+    resumeState;
+    constructor(candidate, resume, context) {
+        super(candidate, resume, context);
+        this.resumeState = { ...(resume?.state ?? {}) };
+    }
+    state() {
+        return { ...this.resumeState };
+    }
+    accept(record) {
+        const index = this.lineIndex++;
+        const payload = record.payload;
+        if (typeof payload !== 'object' || payload === null)
+            return 'ok';
+        const state = this.resumeState;
+        if (record.type === 'session_meta') {
+            // Forked sessions embed their parent's session_meta after their own; only the first counts.
+            if (state.meta)
+                return 'ok';
+            state.meta = true;
+            const source = typeof payload.source === 'string' ? payload.source : null;
+            if (!source || !humanPrompt_1.HUMAN_CODEX_SOURCES.includes(source) || stringField(payload.forked_from_id)) {
+                state.excluded = true;
+                return 'excluded';
+            }
+            state.cwd = stringField(payload.cwd);
+            const git = payload.git;
+            state.gitBranch = git && typeof git === 'object' ? stringField(git.branch) : undefined;
+            return 'ok';
+        }
+        if (record.type === 'turn_context') {
+            const cwd = stringField(payload.cwd);
+            if (cwd)
+                state.cwd = cwd;
+            const model = stringField(payload.model);
+            if (model)
+                state.model = model;
+            return 'ok';
+        }
+        if (record.type === 'response_item' && payload.type === 'message' && payload.role === 'user') {
+            // Without session metadata the source (and thus interactivity) is unknown: fail closed.
+            if (!state.meta) {
+                state.excluded = true;
+                return 'excluded';
+            }
+            const canonical = transcriptMessage(this.candidate, record, 'user', codexBlocks(payload.content), {}, index);
+            const text = (0, humanPrompt_1.humanPromptText)(canonical, 'codex');
+            if (text === null)
+                return 'ok';
+            this.recordPrompt(text, record.timestamp, state.cwd, state.gitBranch);
+            return 'ok';
+        }
+        if (record.type === 'event_msg' && payload.type === 'token_count' && this.pending) {
+            const info = payload.info;
+            const last = info && typeof info === 'object' ? info.last_token_usage : undefined;
+            if (!last || typeof last !== 'object')
+                return 'ok';
+            const input = tokenCount(last.input_tokens);
+            const cached = tokenCount(last.cached_input_tokens);
+            const mapped = compactUsage({
+                inputTokens: input !== undefined ? Math.max(0, input - (cached ?? 0)) : undefined,
+                outputTokens: tokenCount(last.output_tokens),
+                cacheReadTokens: cached,
+                cacheWriteTokens: tokenCount(last.cache_write_input_tokens),
+            });
+            if (mapped)
+                this.pending.usage = mapped;
+            if (state.model)
+                this.pending.model = state.model;
+            this.pending = null;
+        }
+        return 'ok';
+    }
+}
+function codexBlocks(content) {
+    if (!Array.isArray(content))
+        return [];
+    const blocks = [];
+    for (const item of content) {
+        if (typeof item !== 'object' || item === null)
+            continue;
+        const block = item;
+        if ((block.type === 'input_text' || block.type === 'text') && typeof block.text === 'string') {
+            blocks.push({ type: 'text', text: block.text });
+        }
+        else if (block.type === 'input_image') {
+            blocks.push({ type: 'image' });
+        }
+        else {
+            blocks.push({ type: 'unknown' });
+        }
+    }
+    return blocks;
+}

package/dist/schemas/sessionEvent.d.ts

@@ -65,6 +65,11 @@ export declare const userSessionEventSchema: z.ZodObject<{
     entrypoint: z.ZodOptional<z.ZodString>;
     isMeta: z.ZodOptional<z.ZodBoolean>;
     isSidechain: z.ZodOptional<z.ZodBoolean>;
+    isCompactSummary: z.ZodOptional<z.ZodBoolean>;
+    origin: z.ZodOptional<z.ZodObject<{
+        kind: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    promptSource: z.ZodOptional<z.ZodString>;
     cwd: z.ZodOptional<z.ZodString>;
     gitBranch: z.ZodOptional<z.ZodString>;
     permissionMode: z.ZodOptional<z.ZodEnum<{
@@ -145,6 +150,11 @@ export declare const assistantSessionEventSchema: z.ZodObject<{
     entrypoint: z.ZodOptional<z.ZodString>;
     isMeta: z.ZodOptional<z.ZodBoolean>;
     isSidechain: z.ZodOptional<z.ZodBoolean>;
+    isCompactSummary: z.ZodOptional<z.ZodBoolean>;
+    origin: z.ZodOptional<z.ZodObject<{
+        kind: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    promptSource: z.ZodOptional<z.ZodString>;
     cwd: z.ZodOptional<z.ZodString>;
     gitBranch: z.ZodOptional<z.ZodString>;
     permissionMode: z.ZodOptional<z.ZodEnum<{
@@ -226,6 +236,11 @@ export declare const systemSessionEventSchema: z.ZodObject<{
     entrypoint: z.ZodOptional<z.ZodString>;
     isMeta: z.ZodOptional<z.ZodBoolean>;
     isSidechain: z.ZodOptional<z.ZodBoolean>;
+    isCompactSummary: z.ZodOptional<z.ZodBoolean>;
+    origin: z.ZodOptional<z.ZodObject<{
+        kind: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    promptSource: z.ZodOptional<z.ZodString>;
     cwd: z.ZodOptional<z.ZodString>;
     gitBranch: z.ZodOptional<z.ZodString>;
     permissionMode: z.ZodOptional<z.ZodEnum<{
@@ -310,6 +325,11 @@ export declare const toolUseSessionEventSchema: z.ZodObject<{
     entrypoint: z.ZodOptional<z.ZodString>;
     isMeta: z.ZodOptional<z.ZodBoolean>;
     isSidechain: z.ZodOptional<z.ZodBoolean>;
+    isCompactSummary: z.ZodOptional<z.ZodBoolean>;
+    origin: z.ZodOptional<z.ZodObject<{
+        kind: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    promptSource: z.ZodOptional<z.ZodString>;
     cwd: z.ZodOptional<z.ZodString>;
     gitBranch: z.ZodOptional<z.ZodString>;
     permissionMode: z.ZodOptional<z.ZodEnum<{
@@ -395,6 +415,11 @@ export declare const toolResultSessionEventSchema: z.ZodObject<{
     entrypoint: z.ZodOptional<z.ZodString>;
     isMeta: z.ZodOptional<z.ZodBoolean>;
     isSidechain: z.ZodOptional<z.ZodBoolean>;
+    isCompactSummary: z.ZodOptional<z.ZodBoolean>;
+    origin: z.ZodOptional<z.ZodObject<{
+        kind: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    promptSource: z.ZodOptional<z.ZodString>;
     cwd: z.ZodOptional<z.ZodString>;
     gitBranch: z.ZodOptional<z.ZodString>;
     permissionMode: z.ZodOptional<z.ZodEnum<{

package/dist/schemas/sessionEvent.js

@@ -45,6 +45,9 @@ const eventBaseShape = {
     entrypoint: zod_1.z.string().optional(),
     isMeta: zod_1.z.boolean().optional(),
     isSidechain: zod_1.z.boolean().optional(),
+    isCompactSummary: zod_1.z.boolean().optional(),
+    origin: zod_1.z.object({ kind: zod_1.z.string().optional() }).optional(),
+    promptSource: zod_1.z.string().optional(),
     cwd: zod_1.z.string().optional(),
     gitBranch: zod_1.z.string().optional(),
     permissionMode: exports.permissionModeSchema.optional(),

package/dist/transcript.d.ts

@@ -10,6 +10,12 @@ export interface TranscriptSourceProvenance {
     entrypoint?: string;
     isMeta?: boolean;
     isSidechain?: boolean;
+    /** Claude Code compaction/continuation summary flag. */
+    isCompactSummary?: boolean;
+    /** Claude Code `origin.kind` (e.g. `human`, `task-notification`, `coordinator`). */
+    originKind?: string;
+    /** Claude Code `promptSource` (e.g. `typed`, `queued`, `system`). */
+    promptSource?: string;
     originalRole?: string;
     eventIndex: number;
     eventType: SessionEvent['type'];