sidekick-shared 0.29.0 → 0.30.0

package/dist/watchers/jsonlWatcher.js

@@ -9,6 +9,7 @@ const jsonlTail_1 = require("./jsonlTail");
 const codexParser_1 = require("../parsers/codexParser");
 const toolSummary_1 = require("../formatters/toolSummary");
 const claudeUsageDedupe_1 = require("../usage/claudeUsageDedupe");
+const subagentSpawn_1 = require("../subagentSpawn");
 // ── Normalizers ──
 /**
  * Split lines of one Claude response repeat its usage; run the raw usage
@@ -24,7 +25,7 @@ function dedupedClaudeUsage(raw, deduper) {
     }));
     return { usage: event.message?.usage, usageKind: event.message?.usageKind };
 }
-function normalizeClaudeCodeEvent(raw, deduper) {
+function normalizeClaudeCodeEvent(raw, deduper, includeTaskNotifications) {
     const events = [];
     const ts = raw.timestamp || new Date().toISOString();
     const permissionMode = raw.permissionMode;
@@ -136,6 +137,29 @@ function normalizeClaudeCodeEvent(raw, deduper) {
                 raw,
             });
         }
+        else if (includeTaskNotifications) {
+            // A task notification that landed mid-turn is only an attachment line.
+            const prompt = (0, subagentSpawn_1.taskNotificationPromptFromAttachment)(raw);
+            const notification = (0, subagentSpawn_1.parseTaskNotification)(prompt);
+            const stopped = notification ? null : (0, subagentSpawn_1.parseAgentsStoppedNotice)(prompt);
+            const taskStatus = (0, subagentSpawn_1.taskStatusFromAttachment)(raw);
+            let summary = null;
+            if (notification) {
+                summary = notification.summary ?? `Background task ${notification.status ?? 'finished'}`;
+            }
+            else if (stopped) {
+                summary = (0, subagentSpawn_1.describeAgentsStopped)(stopped);
+            }
+            else if (taskStatus && (0, subagentSpawn_1.isFinalTaskStatus)(taskStatus.status)) {
+                summary = (0, subagentSpawn_1.describeTaskStatus)(taskStatus);
+            }
+            else if ((0, subagentSpawn_1.isAgentsKilledSystemEvent)(raw)) {
+                summary = (0, subagentSpawn_1.describeAgentsStopped)(null);
+            }
+            if (summary !== null) {
+                events.push({ providerId: 'claude-code', type: 'system', timestamp: ts, summary, raw });
+            }
+        }
     }
     // Propagate permission mode to all generated events
     if (permissionMode) {
@@ -207,16 +231,18 @@ class JsonlSessionWatcher {
     providerId;
     sessionPath;
     callbacks;
+    options;
     tail;
     startOffset;
     codexInPlanMode = false;
     claudeUsageDeduper = new claudeUsageDedupe_1.ClaudeUsageDeduper();
     /** Last Codex cumulative usage seen; repeated `token_count` events carry the same value. */
     codexPrevTotal;
-    constructor(providerId, sessionPath, callbacks) {
+    constructor(providerId, sessionPath, callbacks, options = {}) {
         this.providerId = providerId;
         this.sessionPath = sessionPath;
         this.callbacks = callbacks;
+        this.options = options;
     }
     get isActive() {
         return this.tail?.isActive ?? false;
@@ -230,6 +256,37 @@ class JsonlSessionWatcher {
     getPosition() {
         return this.tail?.getOffset() ?? this.startOffset ?? 0;
     }
+    /**
+     * Parse state for {@link getPosition}: for Claude Code, the usage deduper's
+     * recent message ids (a `ClaudeUsageDedupeState`); for Codex, the previous
+     * cumulative token total and plan mode.
+     */
+    getResumeState() {
+        if (this.providerId === 'codex') {
+            return {
+                version: 1,
+                prevTotalUsage: this.codexPrevTotal ? { ...this.codexPrevTotal } : null,
+                inPlanMode: this.codexInPlanMode,
+            };
+        }
+        return this.claudeUsageDeduper.exportState();
+    }
+    /** Restores state from {@link getResumeState} after `seekTo()` and before `start()`. */
+    restoreResumeState(state) {
+        if (this.providerId !== 'codex')
+            return this.claudeUsageDeduper.importState(state);
+        if (!state || typeof state !== 'object')
+            return false;
+        const { version, prevTotalUsage, inPlanMode } = state;
+        if (version !== 1 || typeof inPlanMode !== 'boolean')
+            return false;
+        const total = (0, codexParser_1.codexTokenUsageFrom)(prevTotalUsage);
+        if (total === undefined)
+            return false;
+        this.codexPrevTotal = total ?? undefined;
+        this.codexInPlanMode = inPlanMode;
+        return true;
+    }
     start(replay) {
         if (this.isActive)
             return;
@@ -261,7 +318,7 @@ class JsonlSessionWatcher {
         // JsonlParser parses any JSON object. Cast to Record for codex normalizer.
         const followEvents = this.providerId === 'codex'
             ? this.normalizeCodexEvent(event)
-            : normalizeClaudeCodeEvent(event, this.claudeUsageDeduper);
+            : normalizeClaudeCodeEvent(event, this.claudeUsageDeduper, this.options.includeTaskNotifications === true);
         for (const fe of followEvents) {
             this.callbacks.onEvent(fe);
         }

package/dist/watchers/providerReaderWatcher.d.ts

@@ -19,6 +19,13 @@ export declare class ProviderReaderSessionWatcher implements SessionWatcher {
     get isActive(): boolean;
     seekTo(position: number): void;
     getPosition(): number;
+    /** The reader's resume state, if it keeps any. */
+    getResumeState(): unknown;
+    /**
+     * Restores the reader's resume state after `seekTo()`. A reader that keeps
+     * none accepts only `undefined`.
+     */
+    restoreResumeState(state: unknown): boolean;
     start(replay: boolean): void;
     stop(): void;
     private seekToEnd;

package/dist/watchers/providerReaderWatcher.js

@@ -68,6 +68,19 @@ class ProviderReaderSessionWatcher {
     getPosition() {
         return this.reader.getPosition();
     }
+    /** The reader's resume state, if it keeps any. */
+    getResumeState() {
+        return this.reader.getResumeState?.();
+    }
+    /**
+     * Restores the reader's resume state after `seekTo()`. A reader that keeps
+     * none accepts only `undefined`.
+     */
+    restoreResumeState(state) {
+        if (!this.reader.restoreResumeState)
+            return state === undefined;
+        return this.reader.restoreResumeState(state);
+    }
     start(replay) {
         if (this._isActive)
             return;
@@ -135,11 +148,12 @@ class ProviderReaderSessionWatcher {
         if (!this._isActive)
             return;
         try {
-            if (this.reader.wasTruncated()) {
-                this.reader.reset();
-                this.callbacks.onReset?.();
-            }
             const events = this.reader.readNew();
+            // The reader started over (truncated, rewritten, or replaced file):
+            // these events are the session from the beginning, so consumers must
+            // drop what they built before receiving them.
+            if (this.reader.wasTruncated())
+                this.callbacks.onReset?.();
             for (const event of events) {
                 for (const followEvent of (0, eventBridge_1.toFollowEvents)(event, this.provider.id)) {
                     this.callbacks.onEvent(followEvent);

package/dist/watchers/types.d.ts

@@ -70,6 +70,18 @@ export interface SessionWatcher {
     seekTo?(position: number): void;
     /** Get current reader position (byte offset or timestamp). */
     getPosition?(): number;
+    /**
+     * Parse state to persist with `getPosition()` so a later watcher can
+     * resume there without recounting (see `SessionReader.getResumeState`).
+     * `undefined` when the watcher keeps none.
+     */
+    getResumeState?(): unknown;
+    /**
+     * Restores state from `getResumeState()` right after `seekTo()` and before
+     * `start()`. Returns false, changing nothing, when `state` is missing or
+     * not valid; replay from the start instead.
+     */
+    restoreResumeState?(state: unknown): boolean;
 }
 export interface CreateWatcherOptions {
     providerId: ProviderId;

package/dist/zaiQuota.js

@@ -10,6 +10,7 @@ exports.parseZaiQuotaError = parseZaiQuotaError;
 exports.extractNextFlushTime = extractNextFlushTime;
 exports.makeUnavailableZaiQuotaState = makeUnavailableZaiQuotaState;
 exports.rowsToZaiTurnsAndErrors = rowsToZaiTurnsAndErrors;
+const ownKey_1 = require("./ownKey");
 // ── Tier budgets ──
 /**
  * Published z.ai coding-plan prompt budgets.
@@ -227,7 +228,7 @@ function parseZaiQuotaError(error) {
     if (!error)
         return null;
     const code = String(error.code ?? '');
-    const kind = ZAI_ERROR_CODES[code];
+    const kind = (0, ownKey_1.ownValue)(ZAI_ERROR_CODES, code);
     if (!kind)
         return null;
     const message = error.message ?? '';

package/package.json

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