dsh-context 0.43.0 → 0.44.0

package/lib/index.d.ts

@@ -16,6 +16,8 @@ interface Config {
   maxNodes?: number;
   /** Removed (shadowed) surface nodes kept for per-step reconstruction. */
   maxArchiveNodes?: number;
+  /** Fold-derived file-operation records kept (the File Activity card's raw material). */
+  maxFileOps?: number;
 }
 /**
  * The cordis `Config` validator: strict on keys, defaults on the schema fields; tolerates `undefined` (a patch row without a `config:`
@@ -27,6 +29,7 @@ declare const Config: z.ZodPreprocess<z.ZodObject<{
   maxEvents: z.ZodDefault<z.ZodNumber>;
   maxNodes: z.ZodDefault<z.ZodNumber>;
   maxArchiveNodes: z.ZodDefault<z.ZodNumber>;
+  maxFileOps: z.ZodDefault<z.ZodNumber>;
 }, z.core.$strict>>;
 //#endregion
 //#region src/host/headers.d.ts
@@ -103,6 +106,15 @@ interface TimelineState {
    */
   cost?: SessionCostUsage;
   archiveFloor?: number;
+  /**
+   * The detail collections' revision marker (see ContextTimelineDetail):
+   * bumped by every fold that mutates the request records, context events,
+   * live surface, or the removed-node archive — the slim wire head carries
+   * it so an open tab knows its fetched detail went stale. Absent until the
+   * first detail fold (undefined reads as 0; never materialize an
+   * `undefined`-valued property — the plain-JSON precondition above).
+   */
+  detailRev?: number;
   /**
    * Whole-session timing totals (see TimingTotals) — running sums over the
    * COMPLETE session log, like `cost`. Absent until the first step or tool
@@ -126,16 +138,18 @@ interface TimelineState {
     firstToken?: number;
   };
   /**
-   * Tool callId → the call's name and start instant, armed by `tool/call` and
-   * DELETED when its `tool/result` folds in (one result per call, in log
-   * order) — the map stays at pending-call size instead of growing for the
-   * session's whole lifetime (it is persisted state, shallow-copied by every
-   * fold step). The start instant prices the call's duration into
-   * `timing.toolsMs` when the result arrives.
+   * Tool callId → the call's name, start instant, and raw arguments, armed by
+   * `tool/call` and DELETED when its `tool/result` folds in (one result per
+   * call, in log order) — the map stays at pending-call size instead of
+   * growing for the session's whole lifetime (it is persisted state,
+   * shallow-copied by every fold step). The start instant prices the call's
+   * duration into `timing.toolsMs` when the result arrives; the raw arguments
+   * feed the file-op derivation (shared/fileOps.ts) at that same moment.
    */
   callNames: Record<string, {
     name: string;
     start: number;
+    argsRaw?: string;
   }>;
   /**
    * Seq list of the surface nodes the next replacement will shadow, armed by
@@ -156,16 +170,39 @@ interface TimelineState {
    * arm/remove lifecycle as `pendingShadowedSeqs`.
    */
   pendingShadowEventSeq?: number;
+  /**
+   * The fold-derived file-operation log (the File Activity card's raw
+   * material, shared/fileOps.ts): one record per executed file op, appended
+   * in log order — at `tool/result` (the armed call's arguments + the
+   * result's meta) and at a run_code result's flush of its nested
+   * dispatches. Bounded by `maxFileOps`; the trim stamps `fileOpsFloor`.
+   */
+  fileOps: FileOpRecord[];
+  /** The newest dropped op's seq (the card's coverage floor for the served op log). */
+  fileOpsFloor?: number;
+  /**
+   * Nested Code-Mode ops buffered by their top run_code call id until the
+   * parent's result folds (the dispatch events land BEFORE it, and the ops'
+   * locate target is that result's seq). Flushed (and the key deleted) when
+   * the result with that callId folds; absent until the first dispatch books
+   * an op. Bounded by PENDING_CODE_OPS_MAX — a hostile log that never
+   * settles a run_code cannot grow it.
+   */
+  pendingCodeOps?: Record<string, FileOpRecord[]>;
 }
 //#endregion
 //#region src/shared/types.d.ts
 declare module '@deepseek-ai/dsh-session-projection/types' {
   interface SessionProjectionMap {
     /**
-     * The plugin's whole-value context timeline: current composition,
-     * per-request history, context events, and the model-visible surface.
-     * The Host folds it from the session log; clients receive the finished
-     * value (key absence = the plugin's host half is not composed).
+     * The plugin's context timeline: current composition, counters, and the
+     * headline anchor. Since the split generation the wire value is the SLIM
+     * head (every delivery channel — session.list rows, control baselines,
+     * push frames — carries it whole); the per-request history, context
+     * events, and the surface/archive collections ride the on-demand detail
+     * channel ({@link ContextTimelineDetail}, host/detail.ts). Channel-less
+     * hosts keep the inline generation (the collections stay in the value).
+     * Key absence = the plugin's host half is not composed.
      */
     contextTimeline: ContextTimeline;
     /**
@@ -184,6 +221,31 @@ declare module '@deepseek-ai/dsh-session-projection/types' {
   }
 }
 type Category = 'user' | 'inject' | 'assistant' | 'tool';
+/**
+ * The stats board's count figures, precomputed host-side over the RETAINED
+ * request/event records (the same set the detail payload serves). Carried by
+ * the split-generation wire head so the board — and the Agent card's
+ * per-session request tally — never need the collections themselves.
+ * `steps` doubles as the retained request-record count.
+ */
+interface TimelineCounts {
+  turns: number;
+  steps: number;
+  injects: number;
+  compactions: number;
+  prunes: number;
+}
+/**
+ * The newest retained request record's billing summary — the headline's
+ * derived-occupancy anchor (`prompt + surface movement since`), carried by
+ * the split-generation wire head so the headline never needs the request
+ * records themselves.
+ */
+interface TimelineLast {
+  seq: number;
+  total: number;
+  prompt?: number;
+}
 interface Snapshot {
   ok: boolean;
   /**
@@ -209,19 +271,6 @@ interface Snapshot {
     tool: number;
     total: number;
   };
-  /**
-   * Provider-anchored occupancy of the NEXT request. LEGACY since 0.11: the
-   * Host no longer folds this — the Client reads the official token-meter
-   * `contextPressure` projection key (`useProjection('contextPressure')`)
-   * instead. Kept optional for wire compatibility with older clients.
-   */
-  occupancy?: {
-    pressureTokens?: number;
-    surfaceTokens: number;
-    sampledSurfaceTokens?: number;
-    projectedTokens?: number;
-    contextWindow?: number;
-  };
   /**
    * Image blocks live in the CURRENT context (user uploads plus tool-result
    * images, nested blocks included) — the sum over the live surface nodes'
@@ -236,6 +285,23 @@ interface Snapshot {
    * hosts; clients treat absence as zero.
    */
   toolCalls?: number;
+  /**
+   * Split-generation head fields — present exactly when the host serves the
+   * SLIM head (the heavy collections moved to the on-demand detail channel,
+   * host/detail.ts) and absent on the inline generation (older or
+   * channel-less hosts serve the collections in place). `detailRev` is the
+   * detail's revision marker: it bumps whenever the detail collections
+   * change, so an open tab refetches on the push alone.
+   */
+  counts?: TimelineCounts;
+  last?: TimelineLast;
+  detailRev?: number;
+  /**
+   * The per-request history / context-event collections. On the split
+   * generation these stay ABSENT from the wire value (every session.list row,
+   * control baseline, and push frame would carry them whole otherwise); the
+   * client fills them from the detail channel ({@link ContextTimelineDetail}).
+   */
   requests: RequestRecord[];
   events: ContextEventRecord[];
   /**
@@ -276,6 +342,87 @@ interface Snapshot {
    * nodes (the browser shows the reconstruction as approximate).
    */
   archiveFloor?: number;
+  /**
+   * The fold-derived file-operation log and its trim floor — present on the
+   * INLINE wire value (channel-less hosts) and on the detail payload
+   * (ContextTimelineDetail), absent from the slim head (they ride the detail
+   * channel there).
+   */
+  fileOps?: FileOpRecord[];
+  fileOpsFloor?: number;
+}
+/**
+ * The on-demand DETAIL payload of the split `contextTimeline` generation —
+ * the heavy collections (per-request records, context events, the served
+ * surface window, and the removed-node archive) that the slim wire head no
+ * longer carries through every delivery channel. The host serves it off the
+ * live fold state at the `/dsh-context` `detail` endpoint (host/detail.ts);
+ * `rev` mirrors the head's `detailRev` at build time and acts as the
+ * client's latest-wins cursor.
+ */
+interface ContextTimelineDetail {
+  rev: number;
+  requests: RequestRecord[];
+  events: ContextEventRecord[];
+  nodes: SurfaceNode[];
+  droppedNodes: number;
+  archive: SurfaceNode[];
+  surfaceFloor?: number;
+  archiveFloor?: number;
+  /**
+   * The fold-derived file-operation log (shared/fileOps.ts): one record per
+   * executed file op, newest-retained, covering the full log (never
+   * window-bound like the client-side join derivation it replaces on this
+   * generation). Code-Mode nested dispatches book ops located on their
+   * parent run_code result (`parent`).
+   */
+  fileOps?: FileOpRecord[];
+  /** The newest dropped op's seq when the op log trimmed (coverage honesty, same family as archiveFloor). */
+  fileOpsFloor?: number;
+}
+/**
+ * One executed file operation (a settled file-tool call with a resolved
+ * target), folded host-side from the durable tool lifecycle: the call's
+ * name+arguments (`tool/call`), the result's presentation meta and error
+ * (`tool/result`), or a nested Code-Mode settle (`tool/code-dispatch`,
+ * located on its parent run_code result via `parent` + `program`).
+ *
+ * `gone` is NOT host-stamped: the client joins it from the detail's archive
+ * at render time (the op's result node leaving the live surface marks where
+ * its content is still viewable). Line deltas are estimates read off the
+ * call ARGUMENTS (an edit's old/new strings, a write's content), never off
+ * result payloads.
+ */
+interface FileOpRecord {
+  seq: number;
+  /** The op's file; for a pathless search the searched PATTERN (`pattern: true`). */
+  path: string;
+  kind: 'read' | 'write' | 'search';
+  tool: string;
+  time?: number;
+  err: boolean;
+  added: number;
+  removed: number;
+  /** What was searched for, when a search named both a path and a pattern. */
+  detail?: string;
+  /** Meta-attributed search op only: matched lines the result reported for this file. */
+  hits?: number;
+  /** Read ops only: the exact 1-based window the result meta reported, else the `limit`-argument estimate (`est: true`). */
+  read?: {
+    start: number;
+    count: number;
+  } | {
+    count: number;
+    est: true;
+  };
+  /** Nested Code-Mode op only: the run_code result node the op ran under (the locate target). */
+  parent?: number;
+  /** Nested Code-Mode op only: the run_code program's model-authored description. */
+  program?: string;
+  /** The searched-pattern marker: `path` is a pattern, not a file — display must not relativize it. */
+  pattern?: true;
+  /** Client-joined archive stamp (see the type note); absent on the wire. */
+  gone?: number;
 }
 /**
  * The `contextTimeline` projection's whole value — the same snapshot the Client has always rendered. `ok` is always `true` here (a
@@ -461,4 +608,4 @@ declare const name = "dsh-context";
 declare const inject: string[];
 declare function apply(ctx: Context, config: Config): void;
 //#endregion
-export { type Category, Config, type ContextEventRecord, type ContextHeaders, type ContextTimeline, type HeaderRecord, type HeaderTool, type HeadersState, type RequestRecord, type Snapshot, type SurfaceNode, type TimelineState, apply, inject, name };
+export { type Category, Config, type ContextEventRecord, type ContextHeaders, type ContextTimeline, type ContextTimelineDetail, type HeaderRecord, type HeaderTool, type HeadersState, type RequestRecord, type Snapshot, type SurfaceNode, type TimelineCounts, type TimelineLast, type TimelineState, apply, inject, name };