dsh-watcher 0.7.0 → 0.8.0

package/lib/dsh-watcher.js

@@ -2,6 +2,11 @@ import { z } from "zod";
 import { createHash } from "node:crypto";
 //#region src/insights/engine.mjs
 /** Read-only DSH 0.2.0-rc.2 log fold. No prompt, reasoning or tool body is retained. */
+const DAY_CAP = 400;
+const localDayKey = (ms) => {
+	const d = new Date(ms);
+	return `${d.getFullYear()}-${String(d.getMonth() + 1).padStart(2, "0")}-${String(d.getDate()).padStart(2, "0")}`;
+};
 const record = (v) => v !== null && typeof v === "object" && !Array.isArray(v);
 const count = (v) => Number.isSafeInteger(v) && v >= 0;
 const elapsed = (start, end) => start === null ? 0 : Math.max(0, end - start);
@@ -31,7 +36,7 @@ function emptyStats() {
 }
 function initialState(header = {}, inherited = 0) {
 	return {
-		version: 1,
+		version: 2,
 		sessionId: String(header.id ?? ""),
 		skip: inherited,
 		seq: -1,
@@ -42,6 +47,7 @@ function initialState(header = {}, inherited = 0) {
 		},
 		totals: emptyStats(),
 		models: [],
+		days: [],
 		turn: null,
 		open: null,
 		tools: [],
@@ -112,6 +118,33 @@ function books(s, route = s.route) {
 		...s.turn ? [s.turn.stats] : []
 	];
 }
+function creditDay(s, time, route, u) {
+	const key = localDayKey(time);
+	let day = s.days.find((d) => d.key === key);
+	if (!day) {
+		day = {
+			key,
+			tokens: 0,
+			models: []
+		};
+		s.days.push(day);
+		s.days.sort((a, b) => a.key < b.key ? -1 : a.key > b.key ? 1 : 0);
+	}
+	day.tokens += u.tokens;
+	const effort = typeof route?.effort === "string" ? route.effort : null;
+	let row = day.models.find((m) => m.provider === route.provider && m.model === route.model && (m.effort ?? null) === effort);
+	if (!row) {
+		row = {
+			provider: route.provider,
+			model: route.model,
+			...effort ? { effort } : {},
+			tokens: 0
+		};
+		day.models.push(row);
+	}
+	row.tokens += u.tokens;
+	if (s.days.length > DAY_CAP) s.days = s.days.slice(s.days.length - DAY_CAP);
+}
 function begin(s, d, time, uncertain = false) {
 	s.open = {
 		turn: d.turn,
@@ -162,6 +195,7 @@ function settle(s, time, usage, source) {
 			}
 		}
 	}
+	if (u) creditDay(s, time, route, u);
 	s.open = null;
 }
 function applyChunk(open, chunk, time) {
@@ -368,6 +402,7 @@ function buildView(s) {
 		updatedAt: s.updatedAt,
 		totals: s.totals,
 		models: s.models,
+		days: s.days,
 		turn: s.turn,
 		pending: s.open ? {
 			turn: s.open.turn,
@@ -445,8 +480,19 @@ const pending = z.object({
 	reasoningLast: nullableTime,
 	lastContentAt: nullableTime
 }).nullable();
+const dayModels = z.array(z.object({
+	provider: z.string(),
+	model: z.string(),
+	effort: z.string().optional(),
+	tokens: number
+}));
+const days = z.array(z.object({
+	key: z.string(),
+	tokens: number,
+	models: dayModels
+}));
 const viewSchema = z.object({
-	version: z.literal(1),
+	version: z.literal(2),
 	sessionId: z.string(),
 	seq: z.number().int().min(-1),
 	updatedAt: z.number().finite(),
@@ -456,6 +502,7 @@ const viewSchema = z.object({
 		model: z.string(),
 		effort: z.string().optional()
 	})),
+	days,
 	turn,
 	pending,
 	findings: z.array(finding).max(30),
@@ -471,7 +518,7 @@ const usage = z.object({
 	exact: z.boolean()
 }).nullable();
 const stateSchema = z.object({
-	version: z.literal(1),
+	version: z.literal(2),
 	sessionId: z.string(),
 	skip: number,
 	seq: z.number().int().min(-1),
@@ -482,6 +529,7 @@ const stateSchema = z.object({
 		provider: z.string(),
 		model: z.string()
 	})),
+	days,
 	turn,
 	open: z.object({
 		turn: number,
@@ -516,7 +564,7 @@ const stateSchema = z.object({
 function installProjection(ctx) {
 	ctx.sessionProjections.register({
 		key: "watcherInsights",
-		stateVersion: 1,
+		stateVersion: 2,
 		stateSchema,
 		init: (header, inherited) => stateSchema.parse(initialState(header, inherited)),
 		apply: (state, event) => reduceEvent(state, event),

package/lib/types/client/SidebarTab.d.ts

@@ -0,0 +1,52 @@
+import type { ReactNode } from 'react';
+import type { Context as ClientContext } from '@deepseek-ai/cordis';
+import type { SessionId } from '@deepseek-ai/dsh-session/types';
+/**
+ * Minimal structural description of the optional `dsh-better-sidebar` tab
+ * registration service (published as `ctx.betterSidebar`, see the peer's
+ * `client/service.d.ts`). Declared locally on purpose: this package must
+ * typecheck and build without the peer installed, so neither values nor types
+ * may be imported from it. Semantics mirrored here: `registerTab` takes one
+ * descriptor and returns a disposer that unregisters the tab type — hand it to
+ * `ctx.effect` so hot reload cannot register it twice.
+ */
+export interface WatcherSidebarDescriptor {
+    /** Unique tab type id; also the host tab's `type` value. */
+    id: string;
+    title: string;
+    /** Single-instance sugar: opening the tab focuses an existing one. */
+    single?: boolean;
+    /** + menu sort order (ascending); the host default is 100. */
+    order?: number;
+    component: (props: WatcherSidebarTabProps) => ReactNode;
+}
+/** The subset of the host's tab component props the Watcher page reads. */
+export interface WatcherSidebarTabProps {
+    ctx: ClientContext;
+    scope: {
+        sessionId: string;
+    };
+    /** Whether this tab is the active one AND the sidebar panel is open. */
+    visible: boolean;
+}
+/** Structural face of `ctx.betterSidebar` relevant to this plugin. */
+export interface BetterSidebarService {
+    registerTab?: (descriptor: WatcherSidebarDescriptor) => () => void;
+}
+/** Read the optional service off a context without importing the peer. */
+export declare function betterSidebarServiceOf(ctx: ClientContext): BetterSidebarService | undefined;
+/** The Watcher tab descriptor registered into dsh-better-sidebar. */
+export declare function watcherSidebarDescriptor(): WatcherSidebarDescriptor;
+/**
+ * The Better Sidebar tab body: the session-header overlay's work picture,
+ * ported onto `scope.sessionId` without the portal, the trigger, or the drag
+ * frame. Reads the same Session/Conversation stores through their binding
+ * faces; the cost/performance HUD and whole-history paging stay explicit (and
+ * `visible: false` never starts a load — only the button does).
+ */
+export declare function WatcherSidebarTab({ ctx, sessionId, visible }: {
+    ctx: ClientContext;
+    sessionId: SessionId;
+    visible: boolean;
+}): ReactNode;
+//# sourceMappingURL=SidebarTab.d.ts.map

package/lib/types/client/Watcher.d.ts

@@ -1,9 +1,56 @@
 import type { PropsRuntime } from '@deepseek-ai/dsh-client-ui-slots';
 import type { CompleteHistoryResult } from '../hub/history.ts';
+import { type WorkPicture, type WatcherSnapshot } from '../observation/fold.ts';
+import type { SessionId } from '@deepseek-ai/dsh-session/types';
+import type { InsightsView } from '../insights/projection.ts';
+import { type TurnPerformance } from '../observation/performance.ts';
 export interface WatcherInjected {
     loadAllHistory: (signal: AbortSignal) => Promise<CompleteHistoryResult>;
 }
 export type WatcherProps = PropsRuntime<'conversation.session.header.utilities'> & WatcherInjected;
 /** Native session-header utility: exact work picture, typed evidence, no steering. */
 export declare function Watcher(props: WatcherProps): import("react").JSX.Element;
+/**
+ * Folds one Session snapshot into the work picture, merging observations that
+ * outlive the loaded window. Shared by the session-header overlay and the
+ * Better Sidebar tab so both surfaces read the same projection.
+ */
+export declare function useObservedPicture(sessionId: string, snapshot: WatcherSnapshot): {
+    picture: WorkPicture;
+    performanceByTurn: ReadonlyMap<number, TurnPerformance>;
+};
+export interface WorkPicturePanelProps {
+    /** Owning Session identity; changing it resets follow, selection, and history state. */
+    sessionId: SessionId;
+    /** Folded work picture from {@link useObservedPicture}. */
+    picture: WorkPicture;
+    performanceByTurn: ReadonlyMap<number, TurnPerformance>;
+    /** Whether older history pages remain on the Session. */
+    hasMore: boolean;
+    /** Whole-session projection totals, when the Host projection is available. */
+    stats: {
+        turns: number;
+        steps: number;
+    } | undefined;
+    /** Cost/performance HUD input; the header overlay always renders it. */
+    insights: InsightsView | undefined;
+    /** Never mount the cost/performance HUD (the sidebar tab omits it). */
+    hideInsights?: boolean;
+    /** Explicit whole-history loader; absent when no Session face is available. */
+    loadAllHistory?: (signal: AbortSignal) => Promise<CompleteHistoryResult>;
+    /** Gates the live clock: the overlay's open state, or the sidebar tab's visibility. */
+    live: boolean;
+    /** Overlay-only: freeze the floating panel frame across inspector transitions. */
+    onInspectorFrameChange?: () => void;
+    /** DOM id prefix for turn landmarks; coexisting surfaces must not share ids. */
+    domIdPrefix?: string;
+}
+/**
+ * The work picture itself: the docked inspector column plus the turns rail.
+ * Extracted from the session-header overlay so the Better Sidebar tab can
+ * render the same picture without the portal, the trigger, or the drag frame.
+ * Owns every picture-local concern (follow, disclosure, observation mode,
+ * history load, inspector lifecycle); positioning stays with the host.
+ */
+export declare function WorkPicturePanel({ sessionId, picture, performanceByTurn, hasMore, stats, insights, hideInsights, loadAllHistory, live, onInspectorFrameChange, domIdPrefix, }: WorkPicturePanelProps): import("react").JSX.Element;
 //# sourceMappingURL=Watcher.d.ts.map

package/lib/types/client/history-loader.d.ts

@@ -0,0 +1,23 @@
+import type { Context as ClientContext } from '@deepseek-ai/cordis';
+import type { SessionId } from '@deepseek-ai/dsh-session/types';
+import { type CompleteHistoryResult } from '../hub/history.ts';
+/**
+ * The paging verbs the shared loader needs from one Session face. The
+ * session-header injection and the Better Sidebar tab both satisfy it from
+ * `sessions.binding(id).session`.
+ */
+export interface WatcherHistorySession {
+    loadOlder: () => Promise<void>;
+    getSnapshot: () => {
+        hasMore: boolean;
+        loadingOlder: boolean;
+    };
+}
+/**
+ * Build the explicit whole-history loader for one Session: repeat the
+ * Session's public, read-only paging verb until the head stops moving, using
+ * the same conversation head key the header overlay reports. Nothing starts
+ * it automatically — only a user action does.
+ */
+export declare function createCompleteHistoryLoader(ctx: ClientContext, sessionId: SessionId, session: WatcherHistorySession): (signal: AbortSignal) => Promise<CompleteHistoryResult>;
+//# sourceMappingURL=history-loader.d.ts.map

package/lib/types/insights/projection.d.ts

@@ -1,7 +1,7 @@
 import { z } from 'zod';
 import type { Context } from '@deepseek-ai/cordis';
 export declare const viewSchema: z.ZodObject<{
-    version: z.ZodLiteral<1>;
+    version: z.ZodLiteral<2>;
     sessionId: z.ZodString;
     seq: z.ZodNumber;
     updatedAt: z.ZodNumber;
@@ -52,6 +52,16 @@ export declare const viewSchema: z.ZodObject<{
         model: z.ZodString;
         effort: z.ZodOptional<z.ZodString>;
     }, z.core.$strip>>;
+    days: z.ZodArray<z.ZodObject<{
+        key: z.ZodString;
+        tokens: z.ZodNumber;
+        models: z.ZodArray<z.ZodObject<{
+            provider: z.ZodString;
+            model: z.ZodString;
+            effort: z.ZodOptional<z.ZodString>;
+            tokens: z.ZodNumber;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
     turn: z.ZodNullable<z.ZodObject<{
         number: z.ZodNumber;
         startedAt: z.ZodNumber;
@@ -105,7 +115,7 @@ export declare const viewSchema: z.ZodObject<{
     findingCount: z.ZodNumber;
 }, z.core.$strip>;
 declare const stateSchema: z.ZodObject<{
-    version: z.ZodLiteral<1>;
+    version: z.ZodLiteral<2>;
     sessionId: z.ZodString;
     skip: z.ZodNumber;
     seq: z.ZodNumber;
@@ -161,6 +171,16 @@ declare const stateSchema: z.ZodObject<{
         provider: z.ZodString;
         model: z.ZodString;
     }, z.core.$strip>>;
+    days: z.ZodArray<z.ZodObject<{
+        key: z.ZodString;
+        tokens: z.ZodNumber;
+        models: z.ZodArray<z.ZodObject<{
+            provider: z.ZodString;
+            model: z.ZodString;
+            effort: z.ZodOptional<z.ZodString>;
+            tokens: z.ZodNumber;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
     turn: z.ZodNullable<z.ZodObject<{
         number: z.ZodNumber;
         startedAt: z.ZodNumber;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-watcher",
-  "version": "0.7.0",
+  "version": "0.8.0",
   "description": "Read-only DSH session insights and local model usage statistics",
   "type": "module",
   "main": "lib/dsh-watcher.js",