sidekick-shared 0.23.0 → 0.24.0

package/dist/providers/claudeCode.js

@@ -46,11 +46,14 @@ exports.ClaudeCodeProvider = void 0;
 const fs = __importStar(require("fs"));
 const os = __importStar(require("os"));
 const path = __importStar(require("path"));
+const string_decoder_1 = require("string_decoder");
 const sessionContext_1 = require("../context/sessionContext");
 const jsonl_1 = require("../parsers/jsonl");
 const sessionPathResolver_1 = require("../parsers/sessionPathResolver");
 const subagentScanner_1 = require("../parsers/subagentScanner");
 const modelContext_1 = require("../modelContext");
+const sessionEvent_1 = require("../schemas/sessionEvent");
+const usageNormalization_1 = require("../usageNormalization");
 /** Type guard for content blocks with a `type` string property */
 function isTypedBlock(block) {
     return (block !== null &&
@@ -97,10 +100,15 @@ class ClaudeCodeReader {
     filePosition = 0;
     events = [];
     _wasTruncated = false;
+    decoder = new string_decoder_1.StringDecoder('utf8');
     constructor(sessionPath) {
         this.sessionPath = sessionPath;
         this.parser = new jsonl_1.JsonlParser({
-            onEvent: (e) => this.events.push(e),
+            onEvent: (raw) => {
+                for (const event of (0, sessionEvent_1.extractSessionEvents)(raw)) {
+                    this.events.push(normalizeClaudeUsage(event));
+                }
+            },
             onError: (_err, _line) => {
                 // Silently skip parse errors — no logging framework dependency
             },
@@ -120,6 +128,7 @@ class ClaudeCodeReader {
                 this._wasTruncated = true;
                 this.filePosition = 0;
                 this.parser.reset();
+                this.decoder = new string_decoder_1.StringDecoder('utf8');
             }
             // No new content
             if (currentSize <= this.filePosition) {
@@ -129,11 +138,16 @@ class ClaudeCodeReader {
             const fd = fs.openSync(this.sessionPath, 'r');
             const bufferSize = currentSize - this.filePosition;
             const buffer = Buffer.alloc(bufferSize);
-            fs.readSync(fd, buffer, 0, bufferSize, this.filePosition);
-            fs.closeSync(fd);
-            const chunk = buffer.toString('utf-8');
+            let bytesRead = 0;
+            try {
+                bytesRead = fs.readSync(fd, buffer, 0, bufferSize, this.filePosition);
+            }
+            finally {
+                fs.closeSync(fd);
+            }
+            const chunk = this.decoder.write(buffer.subarray(0, bytesRead));
             this.parser.processChunk(chunk);
-            this.filePosition = currentSize;
+            this.filePosition += bytesRead;
         }
         catch (error) {
             console.error(`ClaudeCodeReader: error reading ${this.sessionPath}: ${error}`);
@@ -147,13 +161,18 @@ class ClaudeCodeReader {
     reset() {
         this.filePosition = 0;
         this.parser.reset();
+        this.decoder = new string_decoder_1.StringDecoder('utf8');
         this._wasTruncated = false;
     }
     exists() {
         return fs.existsSync(this.sessionPath);
     }
     flush() {
+        const finalChunk = this.decoder.end();
+        if (finalChunk)
+            this.parser.processChunk(finalChunk);
         this.parser.flush();
+        this.decoder = new string_decoder_1.StringDecoder('utf8');
     }
     getPosition() {
         return this.filePosition;
@@ -161,11 +180,50 @@ class ClaudeCodeReader {
     seekTo(position) {
         this.filePosition = position;
         this.parser.reset();
+        this.decoder = new string_decoder_1.StringDecoder('utf8');
     }
     wasTruncated() {
         return this._wasTruncated;
     }
 }
+function normalizeClaudeUsage(event) {
+    const message = event.message;
+    const usage = message?.usage;
+    if (!message || !usage) {
+        return {
+            ...event,
+            providerMetadata: {
+                ...event.providerMetadata,
+                providerId: 'claude-code',
+                source: 'claude-code-jsonl',
+            },
+        };
+    }
+    return {
+        ...event,
+        message: {
+            ...message,
+            normalizedUsage: (0, usageNormalization_1.normalizeProviderUsage)({
+                semantics: 'anthropic',
+                provider: 'anthropic',
+                source: 'claude-code-jsonl',
+                model: message.model,
+                inputTokens: usage.input_tokens,
+                outputTokens: usage.output_tokens,
+                cacheReadTokens: usage.cache_read_input_tokens,
+                cacheWriteTokens: usage.cache_creation_input_tokens,
+                reasoningTokens: usage.reasoning_tokens,
+                reasoningIncludedInOutput: false,
+                reportedCostUsd: usage.reported_cost,
+            }),
+        },
+        providerMetadata: {
+            ...event.providerMetadata,
+            providerId: 'claude-code',
+            source: 'claude-code-jsonl',
+        },
+    };
+}
 /**
  * Session provider for Claude Code CLI.
  *

package/dist/providers/codex.js

@@ -46,12 +46,14 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.CodexProvider = void 0;
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
+const string_decoder_1 = require("string_decoder");
 const EventAggregator_1 = require("../aggregation/EventAggregator");
 const sessionContext_1 = require("../context/sessionContext");
 const codexParser_1 = require("../parsers/codexParser");
 const codexDatabase_1 = require("./codexDatabase");
 const codexProfiles_1 = require("../codexProfiles");
 const modelContext_1 = require("../modelContext");
+const usageNormalization_1 = require("../usageNormalization");
 // ---------------------------------------------------------------------------
 // Helper functions
 // ---------------------------------------------------------------------------
@@ -131,6 +133,23 @@ function findRolloutFiles(dir) {
     }
     return results;
 }
+function hasRolloutFile(dir) {
+    try {
+        if (!fs.existsSync(dir))
+            return false;
+        for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+            const fullPath = path.join(dir, entry.name);
+            if (entry.isDirectory() && hasRolloutFile(fullPath))
+                return true;
+            if (entry.isFile() && isRolloutFile(entry.name))
+                return true;
+        }
+    }
+    catch {
+        return false;
+    }
+    return false;
+}
 function findRolloutFilesInConfiguredHomes() {
     const results = [];
     const seen = new Set();
@@ -148,7 +167,7 @@ function findRolloutFilesInConfiguredHomes() {
 function getSessionsDir() {
     const dirs = getSessionsDirs();
     for (const dir of dirs) {
-        if (findRolloutFiles(dir).length > 0) {
+        if (hasRolloutFile(dir)) {
             return dir;
         }
     }
@@ -430,6 +449,7 @@ class CodexReader {
     filePosition = 0;
     lineBuffer = '';
     _wasTruncated = false;
+    decoder = new string_decoder_1.StringDecoder('utf8');
     constructor(rolloutPath, onContextWindowLimit, onRateLimits, onTokenUsage) {
         this.rolloutPath = rolloutPath;
         this.onContextWindowLimit = onContextWindowLimit;
@@ -455,6 +475,7 @@ class CodexReader {
                 this.filePosition = 0;
                 this.lineBuffer = '';
                 this.parser.reset();
+                this.decoder = new string_decoder_1.StringDecoder('utf8');
             }
             // No new content
             if (currentSize <= this.filePosition)
@@ -463,10 +484,15 @@ class CodexReader {
             const fd = fs.openSync(this.rolloutPath, 'r');
             const bufferSize = currentSize - this.filePosition;
             const buffer = Buffer.alloc(bufferSize);
-            fs.readSync(fd, buffer, 0, bufferSize, this.filePosition);
-            fs.closeSync(fd);
-            const chunk = buffer.toString('utf-8');
-            this.filePosition = currentSize;
+            let bytesRead = 0;
+            try {
+                bytesRead = fs.readSync(fd, buffer, 0, bufferSize, this.filePosition);
+            }
+            finally {
+                fs.closeSync(fd);
+            }
+            const chunk = this.decoder.write(buffer.subarray(0, bytesRead));
+            this.filePosition += bytesRead;
             // Process lines
             const text = this.lineBuffer + chunk;
             const lines = text.split('\n');
@@ -497,12 +523,22 @@ class CodexReader {
             // Propagate last token usage snapshot to the provider
             const lastUsage = this.parser.getLastTokenUsage();
             if (lastUsage && this.onTokenUsage) {
+                const normalized = (0, usageNormalization_1.normalizeProviderUsage)({
+                    semantics: 'openai',
+                    provider: 'openai',
+                    source: 'codex-reader-snapshot',
+                    model: this.parser.getCurrentModel() || undefined,
+                    inputTokens: lastUsage.input_tokens,
+                    outputTokens: lastUsage.output_tokens,
+                    cacheReadTokens: lastUsage.cached_input_tokens,
+                    reasoningTokens: lastUsage.reasoning_output_tokens,
+                });
                 this.onTokenUsage({
-                    inputTokens: lastUsage.input_tokens || 0,
-                    outputTokens: lastUsage.output_tokens || 0,
-                    cacheWriteTokens: 0,
-                    cacheReadTokens: lastUsage.cached_input_tokens || 0,
-                    reasoningTokens: lastUsage.reasoning_output_tokens || 0,
+                    inputTokens: normalized.uncachedInputTokens,
+                    outputTokens: normalized.outputTokens,
+                    cacheWriteTokens: normalized.cacheWriteTokens,
+                    cacheReadTokens: normalized.cacheReadTokens,
+                    reasoningTokens: normalized.reasoningTokens,
                     model: this.parser.getCurrentModel() || 'unknown',
                     timestamp: new Date(),
                 });
@@ -521,12 +557,14 @@ class CodexReader {
         this.filePosition = 0;
         this.lineBuffer = '';
         this.parser.reset();
+        this.decoder = new string_decoder_1.StringDecoder('utf8');
         this._wasTruncated = false;
     }
     exists() {
         return fs.existsSync(this.rolloutPath);
     }
     flush() {
+        this.lineBuffer += this.decoder.end();
         // Process any remaining data in the line buffer
         if (this.lineBuffer.trim()) {
             try {
@@ -537,6 +575,7 @@ class CodexReader {
                 // Not a complete line yet
             }
         }
+        this.decoder = new string_decoder_1.StringDecoder('utf8');
     }
     getPosition() {
         return this.filePosition;
@@ -544,6 +583,7 @@ class CodexReader {
     seekTo(position) {
         this.filePosition = position;
         this.lineBuffer = '';
+        this.decoder = new string_decoder_1.StringDecoder('utf8');
     }
     wasTruncated() {
         return this._wasTruncated;
@@ -675,9 +715,10 @@ class CodexProvider {
         const db = this.ensureDb();
         if (db) {
             const cwdStats = db.getAllDistinctCwds();
+            const sessionsDir = getSessionsDir();
             for (const stat of cwdStats) {
                 seenCwds.set(stat.cwd, {
-                    dir: getSessionsDir(),
+                    dir: sessionsDir,
                     name: stat.cwd,
                     encodedName: stat.cwd,
                     sessionCount: stat.count,
@@ -837,7 +878,7 @@ class CodexProvider {
                             }
                         }
                         // Accumulate tokens from usage events
-                        if (event.message.usage) {
+                        if (event.message?.usage) {
                             stats.inputTokens += event.message.usage.input_tokens || 0;
                             stats.outputTokens += event.message.usage.output_tokens || 0;
                         }
@@ -971,11 +1012,9 @@ class CodexProvider {
         return this.lastTokenUsageData;
     }
     computeContextSize(usage) {
-        // OpenAI's input_tokens already includes cached_input_tokens (it's a subset,
-        // not additive like Anthropic's model). So inputTokens alone represents the
-        // full context window usage. This differs from OpenCode's formula which adds
-        // cacheWrite + cacheRead because Anthropic reports them separately.
-        return usage.inputTokens;
+        // Codex usage is normalized to the disjoint TokenUsage shape at the reader
+        // boundary, so reconstruct the full prompt/context from uncached + cached.
+        return usage.inputTokens + usage.cacheReadTokens;
     }
     // --- Rate limits (for vscode wrapper to build QuotaState) ---
     /** Get the last rate limits data received from token_count events. */

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) {