sidekick-shared 0.23.0 → 0.23.1

package/dist/providers/detect.js

@@ -100,6 +100,35 @@ function getMostRecentMtime(dir) {
         return 0;
     }
 }
+function getMostRecentFileMtime(dir, isCandidate, depth) {
+    if (depth < 0)
+        return 0;
+    let latest = 0;
+    try {
+        for (const entry of fs.readdirSync(dir)) {
+            const filePath = path.join(dir, entry);
+            try {
+                const stats = fs.statSync(filePath);
+                if (stats.isDirectory?.()) {
+                    latest = Math.max(latest, getMostRecentFileMtime(filePath, isCandidate, depth - 1));
+                }
+                else if (isCandidate(filePath)) {
+                    latest = Math.max(latest, stats.mtime.getTime());
+                }
+            }
+            catch {
+                /* skip */
+            }
+        }
+    }
+    catch {
+        return 0;
+    }
+    return latest;
+}
+function getClaudeActivityMtime(claudeBase) {
+    return getMostRecentFileMtime(claudeBase, (filePath) => filePath.endsWith('.jsonl'), 2);
+}
 function getOpenCodeActivityMtime() {
     const dataDir = (0, openCode_1.getOpenCodeDataDir)();
     const dbPath = path.join(dataDir, 'opencode.db');
@@ -123,7 +152,7 @@ function getCodexActivityMtime() {
         const dbMtime = getCodexStateDbMtime(codexHome);
         if (dbMtime > latest)
             latest = dbMtime;
-        const sessionsMtime = getMostRecentMtime(path.join(codexHome, 'sessions'));
+        const sessionsMtime = getMostRecentFileMtime(path.join(codexHome, 'sessions'), (filePath) => path.basename(filePath).startsWith('rollout-') && filePath.endsWith('.jsonl'), 4);
         if (sessionsMtime > latest)
             latest = sessionsMtime;
     }
@@ -151,7 +180,7 @@ function getAllDetectedProviders() {
     const hasCodex = codexHomes.some((codexHome) => fs.existsSync(path.join(codexHome, 'sessions')) || hasCodexStateDb(codexHome));
     const available = [];
     if (hasClaude)
-        available.push({ id: 'claude-code', mtime: getMostRecentMtime(claudeBase) });
+        available.push({ id: 'claude-code', mtime: getClaudeActivityMtime(claudeBase) });
     if (hasOpenCode)
         available.push({ id: 'opencode', mtime: getOpenCodeActivityMtime() });
     if (hasCodex)
@@ -172,7 +201,7 @@ function detectProvider(override) {
     const hasCodex = codexHomes.some((codexHome) => fs.existsSync(path.join(codexHome, 'sessions')) || hasCodexStateDb(codexHome));
     const available = [];
     if (hasClaude) {
-        available.push({ id: 'claude-code', mtime: getMostRecentMtime(claudeBase) });
+        available.push({ id: 'claude-code', mtime: getClaudeActivityMtime(claudeBase) });
     }
     if (hasOpenCode) {
         available.push({ id: 'opencode', mtime: getOpenCodeActivityMtime() });

package/dist/providers/openCodeDatabase.js

@@ -64,8 +64,12 @@ class OpenCodeDatabase {
         };
     }
     open() {
-        if (this.runtimeStatus)
-            return this.runtimeStatus.available;
+        if (this.runtimeStatus?.kind === 'available')
+            return true;
+        if (this.runtimeStatus &&
+            ['db_missing', 'sqlite_missing', 'sqlite_blocked'].includes(this.runtimeStatus.kind)) {
+            return false;
+        }
         if (!this.isAvailable()) {
             this.runtimeStatus = { available: false, kind: 'db_missing' };
             return false;
@@ -114,7 +118,12 @@ class OpenCodeDatabase {
             return JSON.parse(trimmed);
         }
         catch (error) {
-            this.runtimeStatus = toRuntimeStatus(error, 'query_failed');
+            this.runtimeStatus = {
+                ...toRuntimeStatus(error, 'query_failed'),
+                // The database and sqlite binary were successfully opened. A failed
+                // query is transient and must not gate the next attempt.
+                available: true,
+            };
             return [];
         }
     }

package/dist/quota.js

@@ -12,6 +12,7 @@ exports.withQuotaProjections = withQuotaProjections;
 exports.fetchQuota = fetchQuota;
 const USAGE_URL = 'https://api.anthropic.com/api/oauth/usage';
 const BETA_HEADER = 'oauth-2025-04-20';
+const FETCH_TIMEOUT_MS = 10_000;
 exports.FIVE_HOUR_WINDOW_MS = 5 * 3_600_000;
 exports.SEVEN_DAY_WINDOW_MS = 7 * 86_400_000;
 /**
@@ -94,9 +95,13 @@ function parseRetryAfterMs(retryAfter) {
  * @returns QuotaState with utilization data and elapsed-time projections
  */
 async function fetchQuota(accessToken) {
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), FETCH_TIMEOUT_MS);
+    timeout.unref();
     try {
         const res = await fetch(USAGE_URL, {
             method: 'GET',
+            signal: controller.signal,
             headers: {
                 Authorization: `Bearer ${accessToken}`,
                 'anthropic-beta': BETA_HEADER,
@@ -152,4 +157,7 @@ async function fetchQuota(accessToken) {
     catch {
         return unavailableState('Network error', { failureKind: 'network' });
     }
+    finally {
+        clearTimeout(timeout);
+    }
 }

package/dist/quotaPoller.js

@@ -111,10 +111,12 @@ class QuotaPoller {
                 this.notify(state);
             }
             else if (state.failureKind === 'auth') {
-                // Auth errors: stop polling, notify with error state
+                // Keep polling at the idle cadence so signing in again recovers
+                // without an extension/CLI restart.
                 this.latest = state;
                 this.notify(state);
-                this.stop();
+                this.consecutiveFailures = 0;
+                this.scheduleNext(this.idleIntervalMs);
                 return;
             }
             else {
@@ -134,17 +136,26 @@ class QuotaPoller {
                 }
             }
         }
-        catch {
+        catch (error) {
             this.consecutiveFailures++;
+            const state = {
+                fiveHour: { utilization: 0, resetsAt: '' },
+                sevenDay: { utilization: 0, resetsAt: '' },
+                available: false,
+                error: error instanceof Error ? error.message : String(error),
+                failureKind: 'auth',
+            };
+            this.latest = state;
+            this.notify(state);
         }
         this.scheduleNext();
     }
-    scheduleNext() {
+    scheduleNext(overrideMs) {
         if (this.stopped)
             return;
         const baseInterval = this.isActive ? this.activeIntervalMs : this.idleIntervalMs;
-        const backoff = Math.min(baseInterval * Math.pow(2, this.consecutiveFailures), this.maxBackoffMs);
-        const delay = this.consecutiveFailures > 0 ? backoff : baseInterval;
+        const backoff = Math.min(baseInterval * Math.pow(2, this.consecutiveFailures), Math.max(this.maxBackoffMs, baseInterval));
+        const delay = overrideMs ?? (this.consecutiveFailures > 0 ? backoff : baseInterval);
         this.timer = setTimeout(() => void this.poll(), delay);
     }
     notify(state) {

package/dist/quotaSnapshots.js

@@ -40,6 +40,10 @@ const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
 const paths_1 = require("./paths");
 const codex_1 = require("./types/codex");
+const LOCK_WAIT_MS = 15;
+const LOCK_STALE_MS = 10_000;
+const LOCK_TIMEOUT_MS = 15_000;
+const lockSleepView = new Int32Array(new SharedArrayBuffer(4));
 function getQuotaSnapshotPath() {
     return path.join((0, paths_1.getConfigDir)(), 'quota-snapshots.json');
 }
@@ -84,6 +88,61 @@ function writeStore(store) {
     ensureConfigDir();
     atomicWriteJson(getQuotaSnapshotPath(), store);
 }
+function withSnapshotStoreLock(operation) {
+    ensureConfigDir();
+    const lockPath = `${getQuotaSnapshotPath()}.lock`;
+    const token = `${process.pid}:${crypto.randomBytes(16).toString('hex')}`;
+    const deadline = Date.now() + LOCK_TIMEOUT_MS;
+    while (true) {
+        try {
+            const descriptor = fs.openSync(lockPath, 'wx', 0o600);
+            fs.writeFileSync(descriptor, token, 'utf8');
+            fs.fsyncSync(descriptor);
+            fs.closeSync(descriptor);
+            break;
+        }
+        catch (error) {
+            if (error.code !== 'EEXIST')
+                throw error;
+            try {
+                const stat = fs.statSync(lockPath);
+                if (Date.now() - stat.mtimeMs > LOCK_STALE_MS) {
+                    const owner = fs.readFileSync(lockPath, 'utf8');
+                    const ownerPid = Number.parseInt(owner.split(':', 1)[0], 10);
+                    let ownerAlive = Number.isInteger(ownerPid) && ownerPid > 0;
+                    if (ownerAlive) {
+                        try {
+                            process.kill(ownerPid, 0);
+                        }
+                        catch (ownerError) {
+                            ownerAlive = ownerError.code === 'EPERM';
+                        }
+                    }
+                    if (!ownerAlive)
+                        fs.rmSync(lockPath, { force: true });
+                }
+            }
+            catch {
+                // The owner may have released the lock between checks.
+            }
+            if (Date.now() >= deadline)
+                throw new Error(`Timed out waiting for quota lock: ${lockPath}`);
+            Atomics.wait(lockSleepView, 0, 0, LOCK_WAIT_MS);
+        }
+    }
+    try {
+        return operation();
+    }
+    finally {
+        try {
+            if (fs.readFileSync(lockPath, 'utf8') === token)
+                fs.rmSync(lockPath, { force: true });
+        }
+        catch {
+            // Never remove a lock that has already been released or replaced.
+        }
+    }
+}
 function snapshotTimeMs(quota) {
     const capturedAt = quota.capturedAt ? Date.parse(quota.capturedAt) : NaN;
     return Number.isFinite(capturedAt) ? capturedAt : 0;
@@ -119,32 +178,27 @@ function shouldKeepExistingSnapshot(existing, next) {
     return snapshotTimeMs(existing) > snapshotTimeMs(next);
 }
 function writeQuotaSnapshot(providerId, accountId, quota) {
-    const store = readStore();
-    const index = store.snapshots.findIndex((item) => item.providerId === providerId && item.accountId === accountId);
-    const existingQuota = index >= 0 ? store.snapshots[index].quota : undefined;
-    const snapshot = {
-        ...quota,
-        providerId,
-        capturedAt: quota.capturedAt ?? new Date().toISOString(),
-        source: quota.source ?? 'session',
-        stale: false,
-        resetCredits: quota.resetCredits ?? (providerId === 'codex' ? existingQuota?.resetCredits : undefined),
-    };
-    if (index >= 0 && shouldKeepExistingSnapshot(store.snapshots[index].quota, snapshot)) {
-        return;
-    }
-    const record = {
-        providerId,
-        accountId,
-        quota: snapshot,
-    };
-    if (index >= 0) {
-        store.snapshots[index] = record;
-    }
-    else {
-        store.snapshots.push(record);
-    }
-    writeStore(store);
+    withSnapshotStoreLock(() => {
+        const store = readStore();
+        const index = store.snapshots.findIndex((item) => item.providerId === providerId && item.accountId === accountId);
+        const existingQuota = index >= 0 ? store.snapshots[index].quota : undefined;
+        const snapshot = {
+            ...quota,
+            providerId,
+            capturedAt: quota.capturedAt ?? new Date().toISOString(),
+            source: quota.source ?? 'session',
+            stale: false,
+            resetCredits: quota.resetCredits ?? (providerId === 'codex' ? existingQuota?.resetCredits : undefined),
+        };
+        if (index >= 0 && shouldKeepExistingSnapshot(store.snapshots[index].quota, snapshot))
+            return;
+        const record = { providerId, accountId, quota: snapshot };
+        if (index >= 0)
+            store.snapshots[index] = record;
+        else
+            store.snapshots.push(record);
+        writeStore(store);
+    });
 }
 function readQuotaSnapshot(providerId, accountId) {
     const store = readStore();

package/dist/readers/decisions.js

@@ -9,7 +9,9 @@ async function readDecisions(project, opts) {
     const store = await (0, helpers_1.readProjectJsonStore)(project, 'decisions');
     if (!store)
         return [];
-    let decisions = Object.values(store.decisions);
+    let decisions = store.decisions && typeof store.decisions === 'object' && !Array.isArray(store.decisions)
+        ? Object.values(store.decisions)
+        : [];
     // Sort by timestamp descending
     decisions.sort((a, b) => new Date(b.timestamp).getTime() - new Date(a.timestamp).getTime());
     if (opts?.search) {

package/dist/readers/handoff.js

@@ -42,7 +42,7 @@ const paths_1 = require("../paths");
 async function readLatestHandoff(project) {
     const candidates = typeof project === 'string' ? [project] : project.candidates;
     for (const slug of candidates) {
-        const filePath = (0, paths_1.getProjectDataPath)(slug, 'handoffs').replace('.json', '-latest.md');
+        const filePath = (0, paths_1.getProjectDataPath)(slug, 'handoffs').replace(/\.json$/, '-latest.md');
         try {
             const content = await fs.promises.readFile(filePath, 'utf-8');
             if (content.trim())

package/dist/readers/notes.js

@@ -10,21 +10,26 @@ async function readNotes(project, opts) {
     if (!store)
         return [];
     let notes = [];
+    const notesByFile = store.notesByFile && typeof store.notesByFile === 'object' && !Array.isArray(store.notesByFile)
+        ? store.notesByFile
+        : {};
     if (opts?.file) {
         // Normalize file path for comparison
         const normalizedFile = opts.file.replace(/\\/g, '/');
-        for (const [filePath, fileNotes] of Object.entries(store.notesByFile)) {
+        for (const [filePath, fileNotes] of Object.entries(notesByFile)) {
             const normalizedKey = filePath.replace(/\\/g, '/');
             if (normalizedKey === normalizedFile ||
                 normalizedKey.endsWith('/' + normalizedFile) ||
                 normalizedFile.endsWith('/' + normalizedKey)) {
-                notes.push(...fileNotes);
+                if (Array.isArray(fileNotes))
+                    notes.push(...fileNotes);
             }
         }
     }
     else {
-        for (const fileNotes of Object.values(store.notesByFile)) {
-            notes.push(...fileNotes);
+        for (const fileNotes of Object.values(notesByFile)) {
+            if (Array.isArray(fileNotes))
+                notes.push(...fileNotes);
         }
     }
     if (opts?.type) {

package/dist/readers/plans.js

@@ -48,6 +48,7 @@ const plan_1 = require("../types/plan");
 const paths_1 = require("../paths");
 const helpers_1 = require("./helpers");
 const planExtractor_1 = require("../parsers/planExtractor");
+const atomic_1 = require("../writers/atomic");
 async function readPlans(slug, opts) {
     const filePath = (0, paths_1.getProjectDataPath)(slug, 'plans');
     const store = await (0, helpers_1.readJsonStore)(filePath);
@@ -170,10 +171,7 @@ async function writePlans(slug, plans) {
         plans: capped,
         lastSaved: new Date().toISOString(),
     };
-    // Ensure directory exists
-    const dir = filePath.replace(/[/\\][^/\\]+$/, '');
-    await fs.promises.mkdir(dir, { recursive: true });
-    await fs.promises.writeFile(filePath, JSON.stringify(store, null, 2), 'utf-8');
+    await (0, atomic_1.atomicWriteJson)(filePath, store);
 }
 /**
  * Reads raw plan markdown files from ~/.claude/plans/ that belong to

package/dist/readers/tasks.js

@@ -9,7 +9,9 @@ async function readTasks(project, opts) {
     const store = await (0, helpers_1.readProjectJsonStore)(project, 'tasks');
     if (!store)
         return [];
-    let tasks = Object.values(store.tasks);
+    let tasks = store.tasks && typeof store.tasks === 'object' && !Array.isArray(store.tasks)
+        ? Object.values(store.tasks)
+        : [];
     const status = opts?.status ?? 'all';
     if (status !== 'all') {
         tasks = tasks.filter((t) => t.status === status);

package/dist/report/htmlHelpers.js

@@ -53,7 +53,12 @@ function simpleMarkdownToHtml(text) {
     // Inline code (after escaping so backtick content is already safe)
     result = result.replace(/`([^`]+)`/g, '<code class="inline-code">$1</code>');
     // Links [text](url)
-    result = result.replace(/\[([^\]]+)\]\(([^)]+)\)/g, '<a href="$2" target="_blank" rel="noopener">$1</a>');
+    result = result.replace(/\[([^\]]+)\]\(([^)]+)\)/g, (match, label, url) => {
+        const trimmedUrl = url.trim();
+        if (!/^(?:https?:|mailto:|#|\/)/i.test(trimmedUrl))
+            return match;
+        return `<a href="${trimmedUrl}" target="_blank" rel="noopener">${label}</a>`;
+    });
     // Unordered lists
     result = result.replace(/^(\s*)[-*] (.+)$/gm, '$1<li>$2</li>');
     // Ordered lists

package/dist/report/openBrowser.js

@@ -10,13 +10,13 @@ function openInBrowser(filePath) {
     const url = `file://${filePath}`;
     switch (process.platform) {
         case 'darwin':
-            (0, child_process_1.exec)(`open "${url}"`);
+            (0, child_process_1.execFile)('open', [url]);
             break;
         case 'win32':
-            (0, child_process_1.exec)(`start "" "${url}"`);
+            (0, child_process_1.execFile)('rundll32.exe', ['url.dll,FileProtocolHandler', url]);
             break;
         default:
-            (0, child_process_1.exec)(`xdg-open "${url}"`);
+            (0, child_process_1.execFile)('xdg-open', [url]);
             break;
     }
 }

package/dist/statusline/formatter.js

@@ -42,13 +42,20 @@ function estimateWindowEta(quota, now) {
     const resetAt = Date.parse(quota.fiveHour.resetsAt);
     if (!Number.isFinite(resetAt))
         return null;
+    const nowMs = now.getTime();
+    if (resetAt <= nowMs)
+        return null;
     const capturedAt = quota.capturedAt ? Date.parse(quota.capturedAt) : now.getTime();
     const sampleAt = Number.isFinite(capturedAt) ? capturedAt : now.getTime();
+    if (sampleAt >= resetAt)
+        return null;
     const elapsedMinutes = (sampleAt - (resetAt - quota_1.FIVE_HOUR_WINDOW_MS)) / 60_000;
     if (elapsedMinutes <= 0 || quota.fiveHour.utilization <= 0)
         return null;
     const burnRate = quota.fiveHour.utilization / elapsedMinutes;
-    return (0, BurnRateCalculator_1.estimateTimeToQuota)(quota.fiveHour.utilization, 100, burnRate);
+    const eta = (0, BurnRateCalculator_1.estimateTimeToQuota)(quota.fiveHour.utilization, 100, burnRate);
+    const minutesUntilReset = (resetAt - nowMs) / 60_000;
+    return eta !== null && eta < minutesUntilReset ? eta : null;
 }
 function compactLabel(value) {
     const trimmed = value.trim();

package/dist/terminalSync.js

@@ -107,20 +107,28 @@ function buildShellHookBlock() {
 function getShellRcPaths() {
     const zshrc = path.join(os.homedir(), '.zshrc');
     const bashrc = path.join(os.homedir(), '.bashrc');
-    const paths = [zshrc];
-    if (fs.existsSync(bashrc))
-        paths.push(bashrc);
-    return paths;
+    const existing = [zshrc, bashrc].filter((filePath) => fs.existsSync(filePath));
+    if (existing.length > 0)
+        return existing;
+    const shell = path.basename(process.env.SHELL ?? 'zsh');
+    return shell === 'bash' ? [bashrc] : [zshrc];
+}
+function resolveShellRcTarget(filePath) {
+    if (!fs.existsSync(filePath))
+        return { filePath, mode: 0o600 };
+    const realPath = fs.realpathSync(filePath);
+    return { filePath: realPath, mode: fs.statSync(realPath).mode & 0o777 };
 }
 function stripShellHook(content) {
     const pattern = new RegExp(`${HOOK_START}[\\s\\S]*?${HOOK_END}\\n?`, 'g');
     return content.replace(pattern, '').replace(/\n{3,}/g, '\n\n');
 }
 function installHookInFile(filePath) {
-    const existing = fs.existsSync(filePath) ? fs.readFileSync(filePath, 'utf8') : '';
+    const target = resolveShellRcTarget(filePath);
+    const existing = fs.existsSync(target.filePath) ? fs.readFileSync(target.filePath, 'utf8') : '';
     const cleaned = stripShellHook(existing).replace(/\s*$/, '');
     const next = cleaned ? `${cleaned}\n\n${buildShellHookBlock()}` : buildShellHookBlock();
-    atomicWriteFile(filePath, next, 0o600);
+    atomicWriteFile(target.filePath, next, target.mode);
 }
 function installShellHook() {
     for (const rcPath of getShellRcPaths()) {
@@ -130,7 +138,8 @@ function installShellHook() {
 function uninstallHookInFile(filePath) {
     if (!fs.existsSync(filePath))
         return;
-    atomicWriteFile(filePath, stripShellHook(fs.readFileSync(filePath, 'utf8')), 0o600);
+    const target = resolveShellRcTarget(filePath);
+    atomicWriteFile(target.filePath, stripShellHook(fs.readFileSync(target.filePath, 'utf8')), target.mode);
 }
 function uninstallShellHook() {
     for (const rcPath of getShellRcPaths()) {

package/dist/types/historicalData.d.ts

@@ -51,6 +51,13 @@ export interface DailyData {
     toolUsage: ToolUsageRecord[];
     updatedAt: string;
 }
+export interface HourlyData {
+    hour: number;
+    tokens: TokenTotals;
+    totalCost: number;
+    messageCount: number;
+    sessionCount: number;
+}
 export interface MonthlyData {
     month: string;
     tokens: TokenTotals;
@@ -75,6 +82,8 @@ export interface AllTimeStats {
 export interface HistoricalDataStore {
     schemaVersion: number;
     daily: Record<string, DailyData>;
+    /** Hourly buckets keyed by local YYYY-MM-DD. */
+    hourly?: Record<string, HourlyData[]>;
     monthly: Record<string, MonthlyData>;
     allTime: AllTimeStats;
     lastSaved: string;
@@ -92,6 +101,10 @@ export interface SessionHistoryRecord {
     tokens: TokenTotals;
     totalCost: number;
     messageCount: number;
+    /** Schema v3 additive fields used to make aggregate replacement idempotent. */
+    modelUsage?: ModelUsageRecord[];
+    toolUsage?: ToolUsageRecord[];
+    unpricedModelIds?: string[];
     qualityScore: number;
     qualityFactors: Array<{
         id: string;
@@ -132,3 +145,4 @@ export interface SessionSummary {
     costPerChangedLine?: number | null;
 }
 export declare function createEmptyTokenTotals(): TokenTotals;
+export declare function createEmptyDataStore(): HistoricalDataStore;

package/dist/types/historicalData.js

@@ -18,6 +18,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.HISTORICAL_SESSION_RETENTION_LIMIT = exports.HISTORICAL_DATA_SCHEMA_VERSION = void 0;
 exports.createEmptyTokenTotals = createEmptyTokenTotals;
+exports.createEmptyDataStore = createEmptyDataStore;
 exports.HISTORICAL_DATA_SCHEMA_VERSION = 3;
 exports.HISTORICAL_SESSION_RETENTION_LIMIT = 500;
 function createEmptyTokenTotals() {
@@ -28,3 +29,24 @@ function createEmptyTokenTotals() {
         cacheReadTokens: 0,
     };
 }
+function createEmptyDataStore() {
+    const now = new Date().toISOString();
+    return {
+        schemaVersion: exports.HISTORICAL_DATA_SCHEMA_VERSION,
+        daily: {},
+        monthly: {},
+        sessions: [],
+        allTime: {
+            tokens: createEmptyTokenTotals(),
+            totalCost: 0,
+            messageCount: 0,
+            sessionCount: 0,
+            firstDate: '',
+            lastDate: '',
+            modelUsage: [],
+            toolUsage: [],
+            updatedAt: now,
+        },
+        lastSaved: now,
+    };
+}

package/dist/types/observedSessionV1.js

@@ -10,7 +10,7 @@ function evidence(provider, sessionId, sourcePath, event, eventIndex) {
             sessionId,
             sourcePath,
             eventIndex,
-            eventId: event?.message.id,
+            eventId: event?.message?.id,
             timestamp: event?.timestamp,
         },
     ];
@@ -29,7 +29,7 @@ function derivePendingUserRequestV1(provider, sessionId, sourcePath, events) {
             const refs = evidence(provider, sessionId, sourcePath, event, index);
             return {
                 schemaVersion: 1,
-                id: `${provider}:${sessionId}:${request.id ?? event.message.id ?? index}`,
+                id: `${provider}:${sessionId}:${request.id ?? event.message?.id ?? index}`,
                 provider,
                 sessionId,
                 kind: observed(request.kind, 'inferred', request.kind === 'question' ? 0.95 : 0.9, refs),
@@ -45,11 +45,12 @@ function derivePendingUserRequestV1(provider, sessionId, sourcePath, events) {
 }
 function waitingToolRequest(event) {
     const calls = [];
+    const message = event.message;
     if (event.type === 'tool_use') {
-        calls.push({ id: event.message.id, name: event.tool?.name, input: event.tool?.input });
+        calls.push({ id: message?.id, name: event.tool?.name, input: event.tool?.input });
     }
-    if (Array.isArray(event.message.content)) {
-        for (const block of event.message.content) {
+    if (Array.isArray(message?.content)) {
+        for (const block of message.content) {
             if (!block || typeof block !== 'object')
                 continue;
             const value = block;

package/dist/types/sessionEvent.d.ts

@@ -221,6 +221,7 @@ export interface TimelineEvent {
     metadata?: {
         model?: string;
         toolName?: string;
+        toolUseId?: string;
         isError?: boolean;
         tokenCount?: number;
         fullText?: string;

package/dist/watchers/factory.js

@@ -56,14 +56,25 @@ function createWatcher(options) {
     }
     let sessionPath;
     if (sessionId) {
-        const match = sessions.find((s) => s.includes(sessionId));
-        if (!match) {
+        const matches = sessions.map((sessionPath) => ({
+            sessionPath,
+            id: provider.getSessionId(sessionPath),
+        }));
+        const exact = matches.filter((candidate) => candidate.id === sessionId);
+        const candidates = exact.length > 0 ? exact : matches.filter((candidate) => candidate.id.startsWith(sessionId));
+        if (candidates.length === 0) {
             throw new Error(`Session ${sessionId} not found. Available: ${sessions
                 .slice(0, 5)
                 .map((s) => path.basename(s))
                 .join(', ')}`);
         }
-        sessionPath = match;
+        if (candidates.length > 1) {
+            throw new Error(`Session ${sessionId} is ambiguous. Matches: ${candidates
+                .slice(0, 5)
+                .map((candidate) => candidate.id)
+                .join(', ')}`);
+        }
+        sessionPath = candidates[0].sessionPath;
     }
     else {
         sessionPath = sessions[0]; // most recent