sidekick-shared 0.27.0 → 0.27.1

package/CHANGELOG.md

@@ -5,6 +5,22 @@ All notable changes to sidekick-shared will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [0.27.1] - 2026-09-22
+
+### Fixed
+
+- `collectPromptHistory()` returns a prompt again when its first answering call is written after the prompt was collected. Previously the cursor moved past the prompt and a resumed scan could never attach the answer's `model` / `usage`. Now, while a file's last emitted prompt is not final, the cursor keeps `pending: { ordinal, offset, emitted, state? }`: the byte offset of the prompt's line, a 16-hex digest of the model, usage, and status last returned, and (Codex) the parse state from just before that line. The next call replays from that offset, so the prompt's `provider`, `sessionId`, `ordinal`, `timestamp`, and `text` come from the log again and are never synthesized or renumbered, and returns it only if its metadata digest changed. No prompt or assistant text is stored in the cursor. A replay that would exceed `maxFileBytes` is dropped in favour of the committed offset, and that prompt is not revisited.
+- First-answer attribution: Claude split records of the first call replace usage rather than adding it, a later assistant message id, a `tool_result`, or a non-null `stop_reason` closes the first call, later tool-loop calls never replace it, and `<synthetic>` records (API errors, interrupts) are ignored instead of contributing zero usage. Codex closes on the first `token_count` with `last_token_usage`; a `token_count` without usage (rate-limit only) does not. Missing usage stays `undefined`.
+- Documentation: cursor keys are path-free, but values are not (Codex `state.cwd` / `gitBranch`), so the cursor is sensitive, local-only state; a file over `maxFileBytes` is skipped and calling again with the same bounds skips it again.
+
+### Added
+
+- `PromptHistoryEntry.metadataStatus`: `pending` (no answering call yet), `provisional` (Claude call seen with `stop_reason: null`), or `final` (complete, or closed without an answer). A prompt closed by the next prompt without an answer is returned once more as `final`. New exported types `PromptHistoryMetadataStatus` and `PromptHistoryPendingPrompt`.
+
+### Changed
+
+- `PromptHistoryCursor.version` is now `2` and sessions may carry `pending`. Version 1 cursors are accepted as input and upgraded; prompts they already returned without metadata cannot be recovered. Unknown versions are ignored (full rescan, same identities).
+
 ## [0.27.0] - 2026-09-22
 
 ### Added

package/README.md

@@ -9,6 +9,7 @@ Types, parsers, providers, readers, formatters, aggregation, search, reporting,
 
 ## Recent additions
 
+- **0.27.1: late prompt metadata** — `collectPromptHistory()` returns a prompt again, with the same provider, sessionId, ordinal, timestamp, and text, when its first answering call is written after an earlier collection, and entries gain `metadataStatus` (`pending` / `provisional` / `final`). The cursor becomes `version: 2`, keeps a replay offset and metadata digest for the one open prompt per file (no prompt text), and still accepts 0.27.0 cursors.
 - **0.27.0: human prompt history** — `collectPromptHistory()` (Node-only) returns the prompts a person typed in Claude Code and Codex sessions under a set of workspace roots (plus git worktree siblings), with fail-closed cwd scoping, untruncated text, stable per-session ordinals, the answering model and usage, a JSON-serializable resume cursor, and bounds that stop cleanly and report themselves in `boundsHit`. `isHumanPrompt()` / `humanPromptText()` expose the same classification for any canonical transcript message, and transcript provenance now keeps Claude Code's `isCompactSummary`, `originKind`, and `promptSource`. Claude Opus 5.5 gets its own pricing and context entries.
 - **0.26.6: verified account switching** — `syncLiveAccountState()` reconciles the live Claude Code and Codex logins with saved profiles (registers unknown logins under their email, folds rotated tokens, merges duplicate Codex profiles, re-points the active pointer) and runs at startup, on account-change events, and as phase one of every switch; `getAccountHealth()` / `listAccountsWithHealth()` report secret-free `fresh | expiring | expired | unknown | missing` health; `switchAccount[Async]()` returns a `SwitchAccountResult` with verification, `runningConsumers`, `needsLogin`, and an `undoToken` for `undoLastSwitch()`; `detectRunningAccountConsumers()`, `getAccountLaunchEnv()`, `refreshInactiveAccounts()`, and `getCodexCredentialStoreMode()` are new. Claude logins run `claude auth login`, the Keychain suffix follows Claude Code 2.1.x, and the unused shell-hook helpers were removed.
 - **0.26.5: event-scoped collection** — `ObservedSessionCollector.subscribe()` reconciles each watch event with one `statWatchedSessionFile()` stat and runs a full `discover()` only for unknown paths, catch-up polls, and the initial pass, gated by `minReconcileGapMs`; `discover({ limit, since })` / `collect({ limit, since })` bound a pass, `maxCacheEntries` / `maxCacheBytes` bound the parse cache, `DirectoryListingCache` makes a full pass one stat per unchanged directory, and the info-severity `provider-discovery-completed` diagnostic reports what each pass cost.
@@ -294,7 +295,7 @@ const humanPrompts = transcript.messages
   .map((message) => humanPromptText(message, 'claude-code')); // `/review foo` for slash commands
 ```
 
-A Claude Code message is a human prompt when it has the user role, an entrypoint in `HUMAN_CLAUDE_ENTRYPOINTS` (`cli`, `claude-desktop`, `sdk-cli` — Agent SDK programs report `sdk-ts` / `sdk-py` and are excluded), is not meta, sidechain, or a compaction summary, has no non-human `origin.kind` (task notifications, coordinator messages, auto-continuations) or `promptSource: 'system'`, and is not tool-result-only, local-command output or caveat, a system reminder, or an interrupt marker. A Codex message is one when it has the user role and some text is left after injected `AGENTS.md`, `<environment_context>`, `<user_instructions>`, turn-aborted, skill, subagent-notification, and internal-context blocks and `<image>` wrappers are dropped. Codex session source is a session-level rule: `collectPromptHistory()` reads only sessions whose `session_meta.source` is in `HUMAN_CODEX_SOURCES` (`cli`, `vscode`, `exec`) and skips subagent and forked sessions.
+A Claude Code message is a human prompt when it has the user role, an entrypoint in `HUMAN_CLAUDE_ENTRYPOINTS` (`cli`, `claude-desktop`, `sdk-cli` — Agent SDK programs report `sdk-ts` / `sdk-py` and are excluded), is not meta, sidechain, or a compaction summary, has no non-human `origin.kind` (task notifications, coordinator messages, auto-continuations) or `promptSource: 'system'`, and is not tool-result-only, local-command output or caveat, bash-mode input or output, a hook or task notification, a system reminder, a continued-session summary, or an interrupt marker. A Codex message is one when it has the user role and some text is left after injected `AGENTS.md`, `<environment_context>`, `<user_instructions>`, permissions and collaboration-mode, recommended-plugin, user-shell-command, turn-aborted, skill, subagent-notification, and internal-context blocks and `<image>` wrappers are dropped. Codex session source is a session-level rule: `collectPromptHistory()` reads only sessions whose `session_meta.source` is in `HUMAN_CODEX_SOURCES` (`cli`, `vscode`, `exec`) and skips subagent and forked sessions.
 
 ### Collect human prompt history for workspace roots
 
@@ -317,17 +318,19 @@ const result = await collectPromptHistory({
 });
 
 for (const entry of result.entries) {
-  // { provider, sessionId, ordinal, timestamp, text, cwd, gitBranch?, model?, usage? }
+  // { provider, sessionId, ordinal, timestamp, text, cwd, gitBranch?, model?, usage?, metadataStatus }
+  // Upsert by (provider, sessionId, ordinal): a prompt comes back when its answer metadata changes.
 }
-saveCursor(result.cursor); // unchanged files are skipped next time; appended files resume
+saveCursor(result.cursor); // sensitive local state; unchanged files are skipped next time
 if (result.boundsHit.length > 0) console.warn('partial pass', result.boundsHit, result.stats);
 ```
 
-- **Scope fails closed.** A prompt is returned only when its recorded working directory (the Claude line's `cwd`; the Codex `session_meta` / `turn_context` cwd) realpath-resolves to a root or somewhere inside one. Missing or unresolvable cwds are excluded and counted in `stats.promptsOutOfScope`; Codex scope never comes from the rollout's location. `cwd` is the only path in the output, and cursor keys hold no paths.
+- **Scope fails closed.** A prompt is returned only when its recorded working directory (the Claude line's `cwd`; the Codex `session_meta` / `turn_context` cwd) realpath-resolves to a root or somewhere inside one. Missing or unresolvable cwds are excluded and counted in `stats.promptsOutOfScope`; Codex scope never comes from the rollout's location. `cwd` is the only path in entries. Cursor keys hold no paths, but cursor values can (Codex resume state keeps the session's cwd and branch), so store the cursor as sensitive, local-only state.
 - **Parse-only.** No redaction and no network I/O; text is untruncated.
 - **Ordinals are stable.** Every human prompt in a file consumes one ordinal, even when it is out of scope, older than `since`, or lacks a timestamp (such lines are skipped and counted, never given a synthesized time). Entries are ordered by provider, session, then ordinal.
-- **Model and usage** come from the first model call that answered the prompt (Claude: the first assistant message; Codex: the first `token_count` with the model from `turn_context`). `inputTokens` is uncached input. The last prompt of a still-running session can be returned before its answer exists and is not revisited.
-- **Bounds never throw.** Hitting `maxSessions`, `maxTotalBytes`, the deadline, or an abort stops the pass; a file over `maxFileBytes` is skipped and counted in `stats.filesOverSizeLimit`. An interrupted file contributes no entries, and the cursor covers only fully processed files, so the next call picks up where this one stopped.
+- **Model and usage** come from the first model call that answered the prompt (Claude: the first non-synthetic assistant message, with split records of that call replacing rather than adding usage; Codex: the first `token_count` with the model from `turn_context`). Later tool-loop calls never replace it. `inputTokens` is uncached input, and missing usage stays `undefined`, never zero.
+- **Late answers enrich the same prompt.** A prompt can be collected before its answer is written. `metadataStatus` is `pending` (no answering call yet), `provisional` (Claude call still being written, `stop_reason: null`), or `final`. While a file's last prompt is not final, the cursor keeps the byte offset of its line and a digest of what was returned (never prompt or answer text); the next call replays from that line and returns the prompt again, with the same provider, sessionId, ordinal, timestamp, and text, only when its model, usage, or status changed. A prompt closed by the next prompt without an answer comes back once as `final` with no usage. Consumers should upsert by identity. Cursors from 0.27.0 (`version: 1`) are accepted but cannot recover prompts they already returned without metadata.
+- **Bounds never throw.** Hitting `maxSessions`, `maxTotalBytes`, the deadline, or an abort stops the pass. An interrupted file contributes no entries, and the cursor covers only fully processed files, so the next call picks up where this one stopped. A file over `maxFileBytes` is different: it is skipped and counted in `stats.filesOverSizeLimit`, and calling again with the same bounds skips it again, so raise the bound to make progress on it. When only the replay of a pending prompt would exceed `maxFileBytes`, the replay is dropped and the file continues from its committed offset; that prompt is not revisited.
 
 For an already-open incremental Codex rollout, keep one `CodexRolloutParser` per stream and pass each parsed `SessionEvent[]` batch to `projectSessionTranscript()` (or append the events to an existing projection). This preserves parser state for paired tool calls, model context, and cumulative token deltas; consumers should not convert raw `response_item` rows themselves.
 

package/dist/index.d.ts

@@ -11,7 +11,7 @@ export { projectSessionTranscript } from './transcript';
 export type { TranscriptFidelity, TranscriptSourceProvenance, CanonicalTranscriptBlock, CanonicalTranscriptMessage, CanonicalToolCall, CanonicalTranscriptUsageTotals, CanonicalSessionTranscript, ProjectSessionTranscriptOptions, } from './transcript';
 export { listRecentSessions, readSessionTranscript } from './sessionTranscripts';
 export { collectPromptHistory } from './promptHistory';
-export type { CollectPromptHistoryOptions, PromptHistoryBound, PromptHistoryBounds, PromptHistoryCursor, PromptHistoryCursorSession, PromptHistoryEntry, PromptHistoryProvider, PromptHistoryResult, PromptHistoryResumeState, PromptHistoryStats, PromptHistoryUsage, } from './promptHistory';
+export type { CollectPromptHistoryOptions, PromptHistoryBound, PromptHistoryBounds, PromptHistoryCursor, PromptHistoryCursorSession, PromptHistoryEntry, PromptHistoryMetadataStatus, PromptHistoryPendingPrompt, PromptHistoryProvider, PromptHistoryResult, PromptHistoryResumeState, PromptHistoryStats, PromptHistoryUsage, } from './promptHistory';
 export { HUMAN_CLAUDE_ENTRYPOINTS, HUMAN_CODEX_SOURCES, humanPromptText, isHumanPrompt, } from './humanPrompt';
 export type { HumanPromptProvider } from './humanPrompt';
 export { computeSessionFileStats, firstUserPrompt, providerContextSizeFn, readSessionFileStats, } from './sessionStats';

package/dist/node.d.ts

@@ -11,7 +11,7 @@ export { loadObservedContextWindows, recordObservedContextWindow, getObservedCon
 export type { ObservedContextWindowOptions, ObservedContextWindowStore, } from './observedContextWindows';
 export { listRecentSessions, readSessionTranscript } from './sessionTranscripts';
 export { collectPromptHistory } from './promptHistory';
-export type { CollectPromptHistoryOptions, PromptHistoryBound, PromptHistoryBounds, PromptHistoryCursor, PromptHistoryCursorSession, PromptHistoryEntry, PromptHistoryProvider, PromptHistoryResult, PromptHistoryResumeState, PromptHistoryStats, PromptHistoryUsage, } from './promptHistory';
+export type { CollectPromptHistoryOptions, PromptHistoryBound, PromptHistoryBounds, PromptHistoryCursor, PromptHistoryCursorSession, PromptHistoryEntry, PromptHistoryMetadataStatus, PromptHistoryPendingPrompt, PromptHistoryProvider, PromptHistoryResult, PromptHistoryResumeState, PromptHistoryStats, PromptHistoryUsage, } from './promptHistory';
 export { HUMAN_CLAUDE_ENTRYPOINTS, HUMAN_CODEX_SOURCES, humanPromptText, isHumanPrompt, } from './humanPrompt';
 export type { HumanPromptProvider } from './humanPrompt';
 export { computeSessionFileStats, firstUserPrompt, providerContextSizeFn, readSessionFileStats, } from './sessionStats';

package/dist/promptHistory.d.ts

@@ -7,6 +7,11 @@
  * 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.
+ *
+ * A prompt can be written before its answer. The cursor then keeps the byte
+ * offset of that prompt's line (not its text), the next call replays from it,
+ * and the prompt is returned again under the same identity once its first
+ * answering call brings model or usage (`metadataStatus` says how settled).
  */
 import { type HumanPromptProvider } from './humanPrompt';
 export type PromptHistoryProvider = HumanPromptProvider;
@@ -14,7 +19,10 @@ export type PromptHistoryBound = 'maxSessions' | 'maxFileBytes' | 'maxTotalBytes
 export interface PromptHistoryBounds {
     /** Session files read in one call (unchanged files do not count). Default 1000. */
     maxSessions?: number;
-    /** Bytes a single file may need read in this pass. Default 16 MiB. */
+    /**
+     * Bytes a single file may need read in this pass. Default 16 MiB. A file over
+     * it is skipped, and calling again with the same bounds skips it again.
+     */
     maxFileBytes?: number;
     /** Bytes read across all files in this call. Default 256 MiB. */
     maxTotalBytes?: number;
@@ -31,6 +39,19 @@ export interface PromptHistoryResumeState {
     /** `session_meta` has been seen. */
     meta?: boolean;
 }
+/**
+ * The last emitted prompt of a file whose answering call is not final yet.
+ * Holds a replay position and a metadata digest, never prompt or answer text.
+ */
+export interface PromptHistoryPendingPrompt {
+    ordinal: number;
+    /** Byte offset where the prompt's log line starts; the next pass replays from here. */
+    offset: number;
+    /** Digest of the model, usage, and status last returned for this prompt. */
+    emitted: string;
+    /** Codex parse state as it was just before the prompt line. */
+    state?: PromptHistoryResumeState;
+}
 export interface PromptHistoryCursorSession {
     provider: PromptHistoryProvider;
     sessionId: string;
@@ -41,12 +62,26 @@ export interface PromptHistoryCursorSession {
     /** Byte offset just past the last complete line processed. */
     offset: number;
     state?: PromptHistoryResumeState;
+    pending?: PromptHistoryPendingPrompt;
 }
-/** JSON-serializable resume point. Keys are opaque; they never contain paths. */
+/**
+ * JSON-serializable resume point. Keys are opaque and never contain paths, but
+ * values can (Codex `state.cwd`), so treat the cursor as sensitive local state.
+ * Version 1 cursors from 0.27.0 are accepted as input; output is always version 2.
+ */
 export interface PromptHistoryCursor {
-    version: 1;
+    version: 2;
     sessions: Record<string, PromptHistoryCursorSession>;
 }
+/**
+ * How settled an entry's `model` / `usage` are:
+ * - `pending`: no answering call seen yet.
+ * - `provisional`: the first answering call is still being written (Claude
+ *   `stop_reason: null`); values may change.
+ * - `final`: the first answering call is complete, or the prompt was closed
+ *   without one. Missing usage is then unknown, not zero.
+ */
+export type PromptHistoryMetadataStatus = 'pending' | 'provisional' | 'final';
 export interface PromptHistoryUsage {
     /** Uncached input tokens. */
     inputTokens?: number;
@@ -70,6 +105,12 @@ export interface PromptHistoryEntry {
     model?: string;
     /** Usage of that first answering model call, when known. */
     usage?: PromptHistoryUsage;
+    /**
+     * Whether `model` / `usage` can still change. A prompt that is not `final`
+     * is returned again, with the same provider, sessionId, ordinal, timestamp,
+     * and text, by a later call once its metadata or status changes.
+     */
+    metadataStatus: PromptHistoryMetadataStatus;
 }
 export interface PromptHistoryStats {
     sessionsScanned: number;

package/dist/promptHistory.js

@@ -8,6 +8,11 @@
  * 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.
+ *
+ * A prompt can be written before its answer. The cursor then keeps the byte
+ * offset of that prompt's line (not its text), the next call replays from it,
+ * and the prompt is returned again under the same identity once its first
+ * answering call brings model or usage (`metadataStatus` says how settled).
  */
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
@@ -73,8 +78,8 @@ async function collectPromptHistory(options) {
         promptsMissingTimestamp: 0,
         promptsOutOfScope: 0,
     };
-    const previous = options.cursor?.version === 1 ? options.cursor.sessions : {};
-    const cursor = { version: 1, sessions: { ...previous } };
+    const previous = acceptedCursorSessions(options.cursor);
+    const cursor = { version: 2, sessions: { ...previous } };
     const entries = [];
     const shouldStop = () => {
         if (options.signal?.aborted)
@@ -118,8 +123,9 @@ async function collectPromptHistory(options) {
         }
         // 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;
+        // Replay from the open prompt's line so late answer metadata can reach it.
+        let replay = validPending(resume);
+        let offset = replay?.offset ?? resume?.offset ?? 0;
         if (resume?.state?.excluded) {
             cursor.sessions[candidate.key] = {
                 ...resume,
@@ -130,6 +136,12 @@ async function collectPromptHistory(options) {
             stats.sessionsNotInteractive++;
             continue;
         }
+        if (replay && resume && stat.size - offset > bounds.maxFileBytes) {
+            // Too far to replay: stop waiting on that prompt rather than stall the file.
+            replay = undefined;
+            offset = resume.offset;
+        }
+        const bytesToRead = stat.size - offset;
         if (bytesToRead > bounds.maxFileBytes) {
             stats.filesOverSizeLimit++;
             boundsHit.add('maxFileBytes');
@@ -152,7 +164,7 @@ async function collectPromptHistory(options) {
         }
         totalBytes += buffer.length;
         stats.sessionsScanned++;
-        const outcome = await scanBuffer(candidate, buffer, offset, resume, context);
+        const outcome = await scanBuffer(candidate, buffer, offset, { resume, replay }, context);
         if (outcome.stoppedBy) {
             // Partially processed file: drop its entries and leave its cursor untouched.
             boundsHit.add(outcome.stoppedBy);
@@ -162,7 +174,13 @@ async function collectPromptHistory(options) {
             stats.sessionsNotInteractive++;
         else if (outcome.inScope === 0 && outcome.outOfScope > 0)
             stats.sessionsOutOfScope++;
-        entries.push(...outcome.entries);
+        for (const entry of outcome.entries) {
+            // A replayed prompt is returned again only when its metadata changed.
+            if (replay && entry.ordinal === replay.ordinal && metadataDigest(entry) === replay.emitted) {
+                continue;
+            }
+            entries.push(entry);
+        }
         cursor.sessions[candidate.key] = {
             provider: candidate.provider,
             sessionId: candidate.sessionId,
@@ -171,6 +189,7 @@ async function collectPromptHistory(options) {
             lastOrdinal: outcome.lastOrdinal,
             offset: outcome.offset,
             ...(outcome.state ? { state: outcome.state } : {}),
+            ...(outcome.pending ? { pending: outcome.pending } : {}),
         };
         await yieldToEventLoop();
     }
@@ -187,6 +206,41 @@ function definedBounds(bounds) {
     }
     return result;
 }
+function acceptedCursorSessions(cursor) {
+    if (!cursor || (cursor.version !== 1 && cursor.version !== 2))
+        return {};
+    const sessions = cursor.sessions;
+    return typeof sessions === 'object' && sessions !== null
+        ? sessions
+        : {};
+}
+function validPending(resume) {
+    const pending = resume?.pending;
+    if (!resume || !pending)
+        return undefined;
+    const valid = Number.isInteger(pending.ordinal) &&
+        pending.ordinal === resume.lastOrdinal &&
+        Number.isInteger(pending.offset) &&
+        pending.offset >= 0 &&
+        pending.offset <= resume.offset &&
+        typeof pending.emitted === 'string';
+    return valid ? pending : undefined;
+}
+/** Digest of what a consumer would store for an entry besides its identity and text. */
+function metadataDigest(entry) {
+    const usage = entry.usage
+        ? [
+            entry.usage.inputTokens ?? null,
+            entry.usage.outputTokens ?? null,
+            entry.usage.cacheReadTokens ?? null,
+            entry.usage.cacheWriteTokens ?? null,
+        ]
+        : null;
+    return (0, crypto_1.createHash)('sha256')
+        .update(JSON.stringify([entry.model ?? null, usage, entry.metadataStatus]))
+        .digest('hex')
+        .slice(0, 16);
+}
 function compareEntries(left, right) {
     return (compareStrings(left.provider, right.provider) ||
         compareStrings(left.sessionId, right.sessionId) ||
@@ -311,21 +365,24 @@ async function readRange(filePath, offset, length) {
 function yieldToEventLoop() {
     return new Promise((resolve) => setImmediate(resolve));
 }
-async function scanBuffer(candidate, buffer, startOffset, resume, context) {
+async function scanBuffer(candidate, buffer, startOffset, start, 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 completeLength = lastNewline + 1;
     const scanner = candidate.provider === 'claude-code'
-        ? new ClaudeLineScanner(candidate, resume, context)
-        : new CodexLineScanner(candidate, resume, context);
-    for (let index = 0; index < lines.length; index++) {
+        ? new ClaudeLineScanner(candidate, start, context)
+        : new CodexLineScanner(candidate, start, context);
+    let lineStart = 0;
+    for (let index = 0; lineStart < completeLength; 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];
+        const lineEnd = buffer.indexOf(0x0a, lineStart);
+        const line = buffer.toString('utf8', lineStart, lineEnd);
+        const lineOffset = startOffset + lineStart;
+        lineStart = lineEnd + 1;
         if (!line.trim())
             continue;
         let record;
@@ -337,17 +394,18 @@ async function scanBuffer(candidate, buffer, startOffset, resume, context) {
         }
         if (typeof record !== 'object' || record === null)
             continue;
-        if (scanner.accept(record) === 'excluded') {
+        if (scanner.accept(record, lineOffset) === 'excluded') {
             // Non-interactive Codex session: nothing in it will ever count.
             return {
                 ...scanner.outcome(startOffset + buffer.length),
                 entries: [],
+                pending: undefined,
                 notInteractive: true,
                 stoppedBy: null,
             };
         }
     }
-    return { ...scanner.outcome(startOffset + complete.length), stoppedBy: null };
+    return { ...scanner.outcome(startOffset + completeLength), stoppedBy: null };
 }
 /** Shared per-file prompt bookkeeping for both providers. */
 class LineScanner {
@@ -357,31 +415,49 @@ class LineScanner {
     nextOrdinal;
     inScope = 0;
     outOfScope = 0;
-    pending = null;
-    constructor(candidate, resume, context) {
+    /** Latest emitted prompt still collecting answer metadata. */
+    open = null;
+    constructor(candidate, start, context) {
         this.candidate = candidate;
         this.context = context;
-        this.nextOrdinal = (resume?.lastOrdinal ?? -1) + 1;
+        this.nextOrdinal = start.replay ? start.replay.ordinal : (start.resume?.lastOrdinal ?? -1) + 1;
     }
     state() {
         return undefined;
     }
     outcome(offset) {
         const state = this.state();
+        const open = this.open;
         return {
             entries: this.entries,
             lastOrdinal: this.nextOrdinal - 1,
             offset,
             ...(state ? { state } : {}),
+            ...(open
+                ? {
+                    pending: {
+                        ordinal: open.entry.ordinal,
+                        offset: open.lineOffset,
+                        emitted: metadataDigest(open.entry),
+                        ...(open.stateBefore ? { state: open.stateBefore } : {}),
+                    },
+                }
+                : {}),
             inScope: this.inScope,
             outOfScope: this.outOfScope,
             notInteractive: false,
         };
     }
+    /** The open prompt's answer is complete, or will never arrive. */
+    closeOpen() {
+        if (this.open)
+            this.open.entry.metadataStatus = 'final';
+        this.open = null;
+    }
     /** Assign an ordinal to a human prompt and emit it when in scope. */
-    recordPrompt(text, timestamp, cwd, gitBranch) {
+    recordPrompt(text, timestamp, cwd, gitBranch, lineOffset, stateBefore) {
         const ordinal = this.nextOrdinal++;
-        this.pending = null;
+        this.closeOpen();
         if (typeof timestamp !== 'string' || Number.isNaN(Date.parse(timestamp))) {
             this.context.stats.promptsMissingTimestamp++;
             return;
@@ -403,9 +479,10 @@ class LineScanner {
             text,
             cwd: scoped,
             ...(gitBranch ? { gitBranch } : {}),
+            metadataStatus: 'pending',
         };
         this.entries.push(entry);
-        this.pending = entry;
+        this.open = { entry, lineOffset, ...(stateBefore ? { stateBefore } : {}) };
     }
 }
 function transcriptMessage(candidate, record, role, content, extra, eventIndex) {
@@ -446,14 +523,15 @@ function compactUsage(usage) {
 class ClaudeLineScanner extends LineScanner {
     lineIndex = 0;
     answerId = null;
-    accept(record) {
+    accept(record, lineOffset) {
         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), {
+            const blocks = claudeBlocks(message.content);
+            const canonical = transcriptMessage(this.candidate, record, typeof message.role === 'string' ? message.role : 'user', blocks, {
                 entrypoint: stringField(record.entrypoint),
                 isMeta: record.isMeta === true ? true : undefined,
                 isSidechain: record.isSidechain === true ? true : undefined,
@@ -462,35 +540,54 @@ class ClaudeLineScanner extends LineScanner {
                 promptSource: stringField(record.promptSource),
             }, index);
             const text = (0, humanPrompt_1.humanPromptText)(canonical, 'claude-code');
-            if (text === null)
+            if (text === null) {
+                // A tool result means the first answering call already finished.
+                if (this.answerId !== null &&
+                    record.isSidechain !== true &&
+                    blocks.some((block) => block.type === 'tool_result')) {
+                    this.closeOpen();
+                }
                 return 'ok';
+            }
             this.answerId = null;
-            this.recordPrompt(text, record.timestamp, record.cwd, stringField(record.gitBranch));
+            this.recordPrompt(text, record.timestamp, record.cwd, stringField(record.gitBranch), lineOffset);
             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;
-            }
+        const open = this.open;
+        if (record.type !== 'assistant' || !open || record.isSidechain === true)
+            return 'ok';
+        // Synthetic records (API errors, interrupts) are not model calls.
+        if (message.model === '<synthetic>')
+            return 'ok';
+        const id = stringField(message.id) ?? `line:${index}`;
+        if (this.answerId === null)
+            this.answerId = id;
+        if (id !== this.answerId) {
+            // A later tool-loop call: the first answering call is over and keeps its attribution.
+            this.closeOpen();
+            return 'ok';
+        }
+        const entry = open.entry;
+        const model = stringField(message.model);
+        if (model)
+            entry.model = model;
+        const usage = message.usage;
+        if (usage && typeof usage === 'object') {
+            // Split records of one call repeat its usage; the latest replaces, never adds.
+            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)
+                entry.usage = mapped;
         }
+        // Claude Code writes the call's final stop_reason and usage on every split record.
+        if (stringField(message.stop_reason))
+            this.closeOpen();
+        else
+            entry.metadataStatus = 'provisional';
         return 'ok';
     }
 }
@@ -522,14 +619,16 @@ function claudeBlocks(content) {
 class CodexLineScanner extends LineScanner {
     lineIndex = 0;
     resumeState;
-    constructor(candidate, resume, context) {
-        super(candidate, resume, context);
-        this.resumeState = { ...(resume?.state ?? {}) };
+    constructor(candidate, start, context) {
+        super(candidate, start, context);
+        // A replay restarts at the open prompt's line, so it needs the state from just before it.
+        const initial = start.replay ? start.replay.state : start.resume?.state;
+        this.resumeState = { ...(initial ?? {}) };
     }
     state() {
         return { ...this.resumeState };
     }
-    accept(record) {
+    accept(record, lineOffset) {
         const index = this.lineIndex++;
         const payload = record.payload;
         if (typeof payload !== 'object' || payload === null)
@@ -569,10 +668,14 @@ class CodexLineScanner extends LineScanner {
             const text = (0, humanPrompt_1.humanPromptText)(canonical, 'codex');
             if (text === null)
                 return 'ok';
-            this.recordPrompt(text, record.timestamp, state.cwd, state.gitBranch);
+            this.recordPrompt(text, record.timestamp, state.cwd, state.gitBranch, lineOffset, {
+                ...state,
+            });
             return 'ok';
         }
-        if (record.type === 'event_msg' && payload.type === 'token_count' && this.pending) {
+        const open = this.open;
+        if (record.type === 'event_msg' && payload.type === 'token_count' && open) {
+            // The first token_count after the prompt is the first answering call, complete.
             const info = payload.info;
             const last = info && typeof info === 'object' ? info.last_token_usage : undefined;
             if (!last || typeof last !== 'object')
@@ -586,10 +689,10 @@ class CodexLineScanner extends LineScanner {
                 cacheWriteTokens: tokenCount(last.cache_write_input_tokens),
             });
             if (mapped)
-                this.pending.usage = mapped;
+                open.entry.usage = mapped;
             if (state.model)
-                this.pending.model = state.model;
-            this.pending = null;
+                open.entry.model = state.model;
+            this.closeOpen();
         }
         return 'ok';
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sidekick-shared",
-  "version": "0.27.0",
+  "version": "0.27.1",
   "description": "Shared data access layer for Sidekick — readers, types, providers, credentials, quota",
   "keywords": [
     "claude-code",