dsh-watcher 0.5.1 → 0.7.0

package/lib/dsh-watcher.js

@@ -1,7 +1,7 @@
 import { z } from "zod";
 import { createHash } from "node:crypto";
 //#region src/insights/engine.mjs
-/** Read-only DSH 0.1.5-rc.3 log fold. No prompt, reasoning or tool body is retained. */
+/** Read-only DSH 0.2.0-rc.2 log fold. No prompt, reasoning or tool body is retained. */
 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);

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

@@ -0,0 +1,18 @@
+import type { InsightsView } from '../insights/projection.ts';
+type Evidence = {
+    turn: number;
+    steps: number[];
+    seqs: number[];
+};
+export declare function SessionInsights({ value, now, running, waiting, onEvidence }: {
+    value: InsightsView | undefined;
+    now: number;
+    running: boolean;
+    waiting: boolean;
+    onEvidence: (e: Evidence) => void;
+}): import("react").JSX.Element | null;
+export declare function InsightsSettings(props: {
+    remote?: any;
+}): import("react").JSX.Element;
+export {};
+//# sourceMappingURL=Insights.d.ts.map

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

@@ -0,0 +1,7 @@
+import type { InsightsView } from '../insights/projection.ts';
+export declare function TimingPanel({ stats, scope, tokensPerSecond, }: {
+    stats: InsightsView['totals'];
+    scope: 'turn' | 'session';
+    tokensPerSecond?: number | null;
+}): import("react").JSX.Element;
+//# sourceMappingURL=TimingPanel.d.ts.map

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

@@ -0,0 +1,9 @@
+import type { PropsRuntime } from '@deepseek-ai/dsh-client-ui-slots';
+import type { CompleteHistoryResult } from '../hub/history.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;
+//# sourceMappingURL=Watcher.d.ts.map

package/lib/types/client/disclosure-depth.d.ts

@@ -0,0 +1,22 @@
+export type DisclosureDepth = 'overview' | 'detail';
+export type DisclosureLayer = 'phase' | 'step' | 'cluster' | 'model' | 'reasoning';
+type LayerOverrides = Readonly<Record<DisclosureLayer, Readonly<Record<string, boolean>>>>;
+export interface DisclosureState {
+    readonly depth: DisclosureDepth;
+    readonly turns: Readonly<Record<number, boolean>>;
+    readonly layers: LayerOverrides;
+}
+export declare function createDisclosureState(depth?: DisclosureDepth): DisclosureState;
+/** Overview keeps the automatic Turn policy; detail opens every Turn by default. */
+export declare function turnDisclosureOpen(state: DisclosureState, turn: number, overviewDefaultOpen: boolean): boolean;
+/** Overview stops at phase headers; detail opens every nested level by default. */
+export declare function layerDisclosureOpen(state: DisclosureState, layer: DisclosureLayer, key: string): boolean;
+export declare function setLayerDisclosure(state: DisclosureState, layer: DisclosureLayer, key: string, open: boolean): DisclosureState;
+export declare function toggleTurnDisclosure(state: DisclosureState, turn: number, overviewDefaultOpen: boolean): DisclosureState;
+export declare function toggleLayerDisclosure(state: DisclosureState, layer: DisclosureLayer, key: string): DisclosureState;
+/** Choosing a depth applies it immediately instead of inheriting stale manual folds. */
+export declare function chooseDisclosureDepth(depth: DisclosureDepth): DisclosureState;
+/** Session-specific ids may change, while the user's chosen depth remains useful. */
+export declare function resetDisclosureOverrides(state: DisclosureState): DisclosureState;
+export {};
+//# sourceMappingURL=disclosure-depth.d.ts.map

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

@@ -0,0 +1,9 @@
+import type { Context as ClientContext } from '@deepseek-ai/cordis';
+export declare const name = "dsh-watcher-client";
+export declare const inject: string[];
+/**
+ * Native session-header utility. Order 50 sits after Session log (0)
+ * and before the files-panel toggle (110). No overlay glyph.
+ */
+export declare function apply(ctx: ClientContext): void;
+//# sourceMappingURL=index.d.ts.map

package/lib/types/client/model-trace-definition.d.ts

@@ -0,0 +1,11 @@
+import type { Context as ClientContext } from '@deepseek-ai/cordis';
+import { type ModelStepTrace } from '../observation/model-trace.ts';
+declare module '@deepseek-ai/dsh-client-ui-conversation/client' {
+    interface ConversationStepDataMap {
+        /** Provider-exposed model activity retained for one Step. */
+        'dsh-watcher-model-stage': ModelStepTrace;
+    }
+}
+/** Register the Step-scoped, read-only model-stage projection. */
+export declare function registerModelTraceDefinition(ctx: ClientContext): void;
+//# sourceMappingURL=model-trace-definition.d.ts.map

package/lib/types/client/step-timeline.d.ts

@@ -0,0 +1,15 @@
+import type { WorkItem, WorkStep } from '../observation/fold.ts';
+import type { ModelStepTrace } from '../observation/model-trace.ts';
+type StepTimelineOccurrence = {
+    readonly kind: 'occurrence';
+    readonly item: WorkItem;
+    readonly occurrenceIndex: number;
+};
+export type StepTimelineEntry = StepTimelineOccurrence | {
+    readonly kind: 'model';
+    readonly trace: ModelStepTrace;
+};
+/** Compose the visible rows owned by one authoritative DSH Step. */
+export declare function stepTimelineEntries(step: Pick<WorkStep, 'items' | 'model'>): readonly StepTimelineEntry[];
+export {};
+//# sourceMappingURL=step-timeline.d.ts.map

package/lib/types/dsh-watcher.d.ts

@@ -0,0 +1,6 @@
+import type { Context } from '@deepseek-ai/cordis';
+export declare const name = "dsh-watcher";
+export declare const inject: string[];
+/** Host-owned replayable statistics; no new transport or model-facing writes. */
+export declare function apply(ctx: Context): void;
+//# sourceMappingURL=dsh-watcher.d.ts.map

package/lib/types/hub/aggregation.d.ts

@@ -0,0 +1,40 @@
+import type { WorkItem, WorkStatus } from '../observation/fold.ts';
+export type WorkClusterBasis = 'mutable-target' | 'shared-target' | 'exact-call' | 'single';
+export interface WorkStatusCounts {
+    running: number;
+    waiting: number;
+    success: number;
+    failure: number;
+    returned: number;
+    interrupted: number;
+    unknown: number;
+}
+export type NonEmptyWorkItems = readonly [WorkItem, ...WorkItem[]];
+/** A reversible analysis projection. `items` always retains the source records. */
+export interface WorkCluster {
+    id: string;
+    basis: WorkClusterBasis;
+    title: string;
+    items: NonEmptyWorkItems;
+    executionCount: number;
+    stepCount: number;
+    retryCount: number;
+    iterationCount: number;
+    latestStatus: WorkStatus;
+    statusCounts: Readonly<WorkStatusCounts>;
+}
+/**
+ * Group one phase for analysis without changing evidence identity or order.
+ *
+ * - Mutable calls may group by operation + target so changed inputs remain
+ *   comparable as iterations.
+ * - Reads may group by one exact file target so different line windows stay
+ *   comparable.
+ * - Search, Glob, Grep, Bash, and every other tool require exact normalized
+ *   arguments. Sharing a cwd, broad path, tool name, or translated title is
+ *   never enough.
+ * - Messages and otherwise unsigned records remain singletons.
+ */
+export declare function clusterWorkItems(items: readonly WorkItem[]): readonly WorkCluster[];
+export declare function clusterOutcomeSummary(cluster: WorkCluster): string;
+//# sourceMappingURL=aggregation.d.ts.map

package/lib/types/hub/follow.d.ts

@@ -0,0 +1,29 @@
+import type { WorkPicture } from '../observation/fold.ts';
+export interface FollowSnapshot {
+    follow: boolean;
+    unread: number;
+    selectedId: string | null;
+}
+export interface RailScrollState {
+    atBottom: boolean;
+}
+/**
+ * Follow versus pin state for the work rail.
+ *
+ * The rail follows the newest recorded occurrence by default. Selecting
+ * history or scrolling away pins the viewport; later occurrences and result
+ * updates increment `unread` without yanking the reader away from evidence.
+ */
+export declare function createFollow(): {
+    snapshot: () => FollowSnapshot;
+    /** Counts appended occurrences or a settled live result while pinned. */
+    onPicture(picture: Pick<WorkPicture, "nodes">): FollowSnapshot;
+    onSelect(id: string): FollowSnapshot;
+    onScroll({ atBottom }: RailScrollState): FollowSnapshot;
+    setFollow(next: boolean): FollowSnapshot;
+    backToLatest(): FollowSnapshot;
+    /** Drop a pinned selection without re-arming follow: closing the inspector keeps the rail where the user left it. */
+    clearSelection(): FollowSnapshot;
+    reset(): FollowSnapshot;
+};
+//# sourceMappingURL=follow.d.ts.map

package/lib/types/hub/history.d.ts

@@ -0,0 +1,30 @@
+/** Minimal public facts needed to page one shared RC8 Session window. */
+export interface HistoryWindowState {
+    hasMore: boolean;
+    loadingOlder: boolean;
+    headKey: string;
+}
+export type CompleteHistoryResult = {
+    kind: 'complete';
+    pages: number;
+} | {
+    kind: 'cancelled';
+    pages: number;
+} | {
+    kind: 'blocked';
+    pages: number;
+    reason: 'busy' | 'no-progress' | 'page-limit';
+};
+export interface CompleteHistoryOptions {
+    read: () => HistoryWindowState;
+    loadOlder: () => Promise<void>;
+    signal: AbortSignal;
+    maxPages?: number;
+}
+/**
+ * Pull every older RC8 page in order. The Session remains the sole owner of
+ * history continuity; this helper only repeats its public, read-only paging
+ * verb and fails closed if one request does not advance the visible head.
+ */
+export declare function loadCompleteHistory({ read, loadOlder, signal, maxPages, }: CompleteHistoryOptions): Promise<CompleteHistoryResult>;
+//# sourceMappingURL=history.d.ts.map

package/lib/types/hub/overview.d.ts

@@ -0,0 +1,10 @@
+import type { WorkGroup, WorkStatus, WorkTurn } from '../observation/fold.ts';
+/** Overview progress is deliberately separate from execution evidence status. */
+export type OverviewState = 'active' | 'current' | 'waiting' | 'failure' | 'interrupted' | 'settled' | 'partial';
+export declare const OVERVIEW_STATE_LABEL: Readonly<Record<OverviewState, string>>;
+/** Project evidence status into the one question overview markers answer: where should the user look? */
+export declare function overviewStateOf(status: WorkStatus, isLatest: boolean): OverviewState;
+export declare function groupOverviewSummary(group: WorkGroup): string;
+export declare function turnOverviewSummary(turn: WorkTurn): string;
+export declare function turnNeedsDefaultDisclosure(state: OverviewState, isLatest: boolean): boolean;
+//# sourceMappingURL=overview.d.ts.map

package/lib/types/hub/watcher.d.ts

@@ -0,0 +1,4 @@
+/** Stable model entry for consumers that need Watcher's truthful work picture. */
+export { EMPTY_PICTURE, foldEvents, foldSnapshot, normalizedSignature, pairTools, parseJsonl, } from '../observation/fold.ts';
+export type { WorkGroup, WorkItem, WorkPhase, WorkPicture, WorkPresentation, WorkStatus, WorkStep, WorkTurn, } from '../observation/fold.ts';
+//# sourceMappingURL=watcher.d.ts.map

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

@@ -0,0 +1,263 @@
+import { z } from 'zod';
+import type { Context } from '@deepseek-ai/cordis';
+export declare const viewSchema: z.ZodObject<{
+    version: z.ZodLiteral<1>;
+    sessionId: z.ZodString;
+    seq: z.ZodNumber;
+    updatedAt: z.ZodNumber;
+    totals: z.ZodObject<{
+        calls: z.ZodNumber;
+        reported: z.ZodNumber;
+        exactTotals: z.ZodNumber;
+        tokens: z.ZodNumber;
+        input: z.ZodNumber;
+        output: z.ZodNumber;
+        cacheRead: z.ZodNumber;
+        cacheWrite: z.ZodNumber;
+        reasoning: z.ZodNumber;
+        reasoningReports: z.ZodNumber;
+        modelMs: z.ZodNumber;
+        timedCalls: z.ZodNumber;
+        firstMs: z.ZodNumber;
+        firstSamples: z.ZodNumber;
+        reasoningMs: z.ZodNumber;
+        tools: z.ZodNumber;
+        toolErrors: z.ZodNumber;
+        toolMs: z.ZodNumber;
+        bashMs: z.ZodOptional<z.ZodNumber>;
+        retries: z.ZodNumber;
+    }, z.core.$strip>;
+    models: z.ZodArray<z.ZodObject<{
+        calls: z.ZodNumber;
+        reported: z.ZodNumber;
+        exactTotals: z.ZodNumber;
+        tokens: z.ZodNumber;
+        input: z.ZodNumber;
+        output: z.ZodNumber;
+        cacheRead: z.ZodNumber;
+        cacheWrite: z.ZodNumber;
+        reasoning: z.ZodNumber;
+        reasoningReports: z.ZodNumber;
+        modelMs: z.ZodNumber;
+        timedCalls: z.ZodNumber;
+        firstMs: z.ZodNumber;
+        firstSamples: z.ZodNumber;
+        reasoningMs: z.ZodNumber;
+        tools: z.ZodNumber;
+        toolErrors: z.ZodNumber;
+        toolMs: z.ZodNumber;
+        bashMs: z.ZodOptional<z.ZodNumber>;
+        retries: z.ZodNumber;
+        provider: z.ZodString;
+        model: z.ZodString;
+        effort: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    turn: z.ZodNullable<z.ZodObject<{
+        number: z.ZodNumber;
+        startedAt: z.ZodNumber;
+        endedAt: z.ZodNullable<z.ZodNumber>;
+        steps: z.ZodNumber;
+        stats: z.ZodObject<{
+            calls: z.ZodNumber;
+            reported: z.ZodNumber;
+            exactTotals: z.ZodNumber;
+            tokens: z.ZodNumber;
+            input: z.ZodNumber;
+            output: z.ZodNumber;
+            cacheRead: z.ZodNumber;
+            cacheWrite: z.ZodNumber;
+            reasoning: z.ZodNumber;
+            reasoningReports: z.ZodNumber;
+            modelMs: z.ZodNumber;
+            timedCalls: z.ZodNumber;
+            firstMs: z.ZodNumber;
+            firstSamples: z.ZodNumber;
+            reasoningMs: z.ZodNumber;
+            tools: z.ZodNumber;
+            toolErrors: z.ZodNumber;
+            toolMs: z.ZodNumber;
+            bashMs: z.ZodOptional<z.ZodNumber>;
+            retries: z.ZodNumber;
+        }, z.core.$strip>;
+        route: z.ZodOptional<z.ZodObject<{
+            provider: z.ZodString;
+            model: z.ZodString;
+            effort: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+    pending: z.ZodNullable<z.ZodObject<{
+        turn: z.ZodNumber;
+        step: z.ZodNumber;
+        start: z.ZodNullable<z.ZodNumber>;
+        reasoningFirst: z.ZodNullable<z.ZodNumber>;
+        reasoningLast: z.ZodNullable<z.ZodNumber>;
+        lastContentAt: z.ZodNullable<z.ZodNumber>;
+    }, z.core.$strip>>;
+    findings: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        kind: z.ZodString;
+        turn: z.ZodNumber;
+        seqs: z.ZodArray<z.ZodNumber>;
+        steps: z.ZodArray<z.ZodNumber>;
+        title: z.ZodString;
+        detail: z.ZodString;
+    }, z.core.$strip>>;
+    findingCount: z.ZodNumber;
+}, z.core.$strip>;
+declare const stateSchema: z.ZodObject<{
+    version: z.ZodLiteral<1>;
+    sessionId: z.ZodString;
+    skip: z.ZodNumber;
+    seq: z.ZodNumber;
+    updatedAt: z.ZodNumber;
+    route: z.ZodObject<{
+        provider: z.ZodString;
+        model: z.ZodString;
+        effort: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    }, z.core.$strip>;
+    totals: z.ZodObject<{
+        calls: z.ZodNumber;
+        reported: z.ZodNumber;
+        exactTotals: z.ZodNumber;
+        tokens: z.ZodNumber;
+        input: z.ZodNumber;
+        output: z.ZodNumber;
+        cacheRead: z.ZodNumber;
+        cacheWrite: z.ZodNumber;
+        reasoning: z.ZodNumber;
+        reasoningReports: z.ZodNumber;
+        modelMs: z.ZodNumber;
+        timedCalls: z.ZodNumber;
+        firstMs: z.ZodNumber;
+        firstSamples: z.ZodNumber;
+        reasoningMs: z.ZodNumber;
+        tools: z.ZodNumber;
+        toolErrors: z.ZodNumber;
+        toolMs: z.ZodNumber;
+        bashMs: z.ZodOptional<z.ZodNumber>;
+        retries: z.ZodNumber;
+    }, z.core.$strip>;
+    models: z.ZodArray<z.ZodObject<{
+        calls: z.ZodNumber;
+        reported: z.ZodNumber;
+        exactTotals: z.ZodNumber;
+        tokens: z.ZodNumber;
+        input: z.ZodNumber;
+        output: z.ZodNumber;
+        cacheRead: z.ZodNumber;
+        cacheWrite: z.ZodNumber;
+        reasoning: z.ZodNumber;
+        reasoningReports: z.ZodNumber;
+        modelMs: z.ZodNumber;
+        timedCalls: z.ZodNumber;
+        firstMs: z.ZodNumber;
+        firstSamples: z.ZodNumber;
+        reasoningMs: z.ZodNumber;
+        tools: z.ZodNumber;
+        toolErrors: z.ZodNumber;
+        toolMs: z.ZodNumber;
+        bashMs: z.ZodOptional<z.ZodNumber>;
+        retries: z.ZodNumber;
+        provider: z.ZodString;
+        model: z.ZodString;
+    }, z.core.$strip>>;
+    turn: z.ZodNullable<z.ZodObject<{
+        number: z.ZodNumber;
+        startedAt: z.ZodNumber;
+        endedAt: z.ZodNullable<z.ZodNumber>;
+        steps: z.ZodNumber;
+        stats: z.ZodObject<{
+            calls: z.ZodNumber;
+            reported: z.ZodNumber;
+            exactTotals: z.ZodNumber;
+            tokens: z.ZodNumber;
+            input: z.ZodNumber;
+            output: z.ZodNumber;
+            cacheRead: z.ZodNumber;
+            cacheWrite: z.ZodNumber;
+            reasoning: z.ZodNumber;
+            reasoningReports: z.ZodNumber;
+            modelMs: z.ZodNumber;
+            timedCalls: z.ZodNumber;
+            firstMs: z.ZodNumber;
+            firstSamples: z.ZodNumber;
+            reasoningMs: z.ZodNumber;
+            tools: z.ZodNumber;
+            toolErrors: z.ZodNumber;
+            toolMs: z.ZodNumber;
+            bashMs: z.ZodOptional<z.ZodNumber>;
+            retries: z.ZodNumber;
+        }, z.core.$strip>;
+        route: z.ZodOptional<z.ZodObject<{
+            provider: z.ZodString;
+            model: z.ZodString;
+            effort: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+    open: z.ZodNullable<z.ZodObject<{
+        turn: z.ZodNumber;
+        step: z.ZodNumber;
+        start: z.ZodNullable<z.ZodNumber>;
+        first: z.ZodNullable<z.ZodNumber>;
+        reasoningFirst: z.ZodNullable<z.ZodNumber>;
+        reasoningLast: z.ZodNullable<z.ZodNumber>;
+        lastContentAt: z.ZodNullable<z.ZodNumber>;
+        usage: z.ZodNullable<z.ZodObject<{
+            input: z.ZodNumber;
+            output: z.ZodNumber;
+            cacheRead: z.ZodNumber;
+            cacheWrite: z.ZodNumber;
+            reasoning: z.ZodNullable<z.ZodNumber>;
+            tokens: z.ZodNumber;
+            exact: z.ZodBoolean;
+        }, z.core.$strip>>;
+        route: z.ZodObject<{
+            provider: z.ZodString;
+            model: z.ZodString;
+            effort: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        }, z.core.$strip>;
+    }, z.core.$strip>>;
+    tools: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodString;
+        start: z.ZodNumber;
+        seq: z.ZodNumber;
+        step: z.ZodNumber;
+        route: z.ZodObject<{
+            provider: z.ZodString;
+            model: z.ZodString;
+            effort: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        }, z.core.$strip>;
+        signature: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>>;
+    previousFailure: z.ZodNullable<z.ZodObject<{
+        signature: z.ZodString;
+        resultHash: z.ZodString;
+        turn: z.ZodNumber;
+        seqs: z.ZodArray<z.ZodNumber>;
+        steps: z.ZodArray<z.ZodNumber>;
+    }, z.core.$strip>>;
+    findings: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        kind: z.ZodString;
+        turn: z.ZodNumber;
+        seqs: z.ZodArray<z.ZodNumber>;
+        steps: z.ZodArray<z.ZodNumber>;
+        title: z.ZodString;
+        detail: z.ZodString;
+    }, z.core.$strip>>;
+    findingCount: z.ZodNumber;
+}, z.core.$strip>;
+export type InsightsView = z.infer<typeof viewSchema>;
+type InsightsState = z.infer<typeof stateSchema>;
+declare module '@deepseek-ai/dsh-session-projection/types' {
+    interface SessionProjectionStateMap {
+        watcherInsights: InsightsState;
+    }
+    interface SessionProjectionMap {
+        watcherInsights: InsightsView;
+    }
+}
+export declare function installProjection(ctx: Context): void;
+export {};
+//# sourceMappingURL=projection.d.ts.map