Merge remote-tracking branch 'origin/master' into session-fork

# Conflicts:
#	docs/architecture.md
#	docs/cordis-catalog/services.md

packages/core/session/src/index.ts

@@ -8,11 +8,13 @@
 
 import { Context, Service } from 'cordis'
 import { isAbsolute } from 'node:path'
+import { deepFreeze } from '@deepseek-ai/dsh-llm'
 import type { ContentBlock, Message, MessageSource } from '@deepseek-ai/dsh-llm'
 import { SESSION_FORMAT_VERSION, SessionId } from './types.ts'
-import type { CreateSessionOptions, SessionEvent, SessionEventMap, SessionEventType, SessionHeader, SurfaceIntent, SurfaceEventType } from './types.ts'
+import type { CreateSessionOptions, EpochHeader, SessionEvent, SessionEventMap, SessionEventType, SessionHeader, SurfaceIntent, SurfaceEventType } from './types.ts'
 import { isJsonValue } from './json.ts'
 import { SurfaceManager, isSurfaceEligibleType } from './surface.ts'
+import { foldRequestHeader } from './request-header.ts'
 
 export * from './types.ts'
 export { isJsonValue } from './json.ts'
@@ -21,6 +23,7 @@ export { interruptedTurnClosers } from './repair.ts'
 export type { SurfaceNode } from './surface.ts'
 export { isSurfaceEvent, isSurfaceEligibleType } from './surface.ts'
 export { isToolPairingBalanced } from './tool-pairing.ts'
+export { applyHeaderDelta, canonicalHeader, diffHeader, foldRequestHeader, headerEquals } from './request-header.ts'
 
 declare module 'cordis' {
   interface Context {
@@ -234,53 +237,93 @@ export class Session {
     return event
   }
 
+  /** Cached fold of the request-header events — see {@link requestHeader}. */
+  private headerFold: EpochHeader | undefined
+  /** Log position (events consumed) the header fold has reached. */
+  private headerFoldSeq = 0
+
+  /**
+   * The {@link EpochHeader} in force after the log's last header event — the
+   * header the NEXT request will be compared against — or undefined before
+   * the first `request/header` snapshot. The live, incrementally-maintained
+   * form of `foldRequestHeader(session.events)`: each header event is folded
+   * once, when first seen, so a per-step read costs O(new events).
+   * @returns the folded header, or undefined when no header event exists yet.
+   */
+  requestHeader(): EpochHeader | undefined {
+    if (this.headerFoldSeq < this.log.length) {
+      // Frozen on update: the fold is session state exposed by reference — a
+      // consumer mutating it in place (instead of building a replacement)
+      // would desync every later comparison against the log, so mutation
+      // throws instead.
+      this.headerFold = deepFreeze(foldRequestHeader(this.log.slice(this.headerFoldSeq), this.headerFold))
+      this.headerFoldSeq = this.log.length
+    }
+    return this.headerFold
+  }
+
+  /** The derived-message cache: frozen projections, extended per unseen node. */
+  private derived: Message[] = []
+  /** Surface position (nodes projected) the cache has reached. */
+  private derivedNodes = 0
+  /** {@link SurfaceManager.replaceGeneration} the cache was built under. */
+  private derivedGeneration = 0
+
   /**
    * Derive the LLM message history by walking the session surface — the linked
    * list of message-producing events maintained by `surfaceOp` markers. The
    * surface is the single source of derived history: every message-producing
    * append records its `surfaceOp`, so a raw event with no marker (a chunk, a
    * turn boundary) is correctly absent, and a compaction `replace` deletes the
-   * shadowed nodes from the derivation.
+   * shadowed nodes from the derivation. The projection rules are
+   * {@link deriveEventMessage}, folded per node.
    *
-   * - `user/message` → user message
-   * - `assistant/message` → assistant message (chunks are skipped — they are
-   *   replay/UI data; the assembled message is authoritative for history). An
-   *   EMPTY-content assistant/message is skipped: a max-tokens step cut off with
-   *   no content still records an assistant/message to host its `usage`, but a
-   *   content-less assistant turn must not enter the provider transcript.
-   * - `tool/result` → user message carrying a tool-result block
-   * - `context/message` / `steering/message` → tagged synthetic user messages
-   *   at their chronological position
-   *
-   * The returned `content` is **deep-cloned** off the logged events: the loop
-   * hands these messages into the mutable `agent/request` waterfall and on to
-   * adapters, where mutating the request is sanctioned — but the session log
-   * is append-only by contract. Cloning at this boundary keeps in-flight
-   * mutation from reaching back and rewriting history (which would silently
-   * break replay equivalence). Cost is one structured clone per step,
-   * negligible next to a model call.
+   * CACHED: each surface node is projected exactly once, when first seen — a
+   * call costs O(new nodes), and a surface rewrite (a `replace`;
+   * {@link SurfaceManager.replaceGeneration}) rebuilds. The returned array is
+   * a fresh snapshot per call (later appends never grow an array a caller
+   * already holds); the `Message` objects in it are SHARED and **deep-frozen**
+   * — cloned once off the log at projection time, so consumers can never
+   * mutate logged data, and mutation attempts throw instead of silently
+   * diverging replay from history.
+   * @returns a fresh array of the shared, frozen derived history.
    */
   deriveMessages(): Message[] {
-    const messages: Message[] = []
-    for (const node of this.surface.nodes) {
+    const nodes = this.surface.nodes
+    const generation = this.surface.replaceGeneration
+    if (generation !== this.derivedGeneration) {
+      this.derived = []
+      this.derivedNodes = 0
+      this.derivedGeneration = generation
+    }
+    for (const node of nodes.slice(this.derivedNodes)) {
       // Surface nodes are built from this.log — node.seq is always a valid
       // index by construction. The non-null assertion expresses that invariant.
       // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-      const msg = this._deriveOneMessage(this.log[node.seq]!)
+      const msg = this.deriveEventMessage(this.log[node.seq]!)
       // A surface node is one of the five message-producing types, but an
       // empty-content assistant/message (a max-tokens step that hosts only
       // usage) derives to null and must not enter the transcript.
-      if (msg) messages.push(msg)
+      if (msg) this.derived.push(deepFreeze(msg))
     }
-    return messages
+    this.derivedNodes = nodes.length
+    return [...this.derived]
   }
 
   /**
-   * Derive a single LLM message from one surface event, or null if it produces
-   * no message (an empty-content assistant/message that exists only to host
-   * usage).
+   * Project a single event into the LLM message it derives to, or null when
+   * it produces none — a non-surface event (chunk, boundary, log-only record)
+   * or an empty-content assistant/message (which exists only to host usage).
+   * The per-node pure function {@link deriveMessages} folds over the surface;
+   * an external reconstructor (or the dev invariant) folds the same function
+   * over a log prefix's surface to rebuild the exact messages any request was
+   * built from (the reconstructability RFC). The returned `content` is
+   * deep-cloned off the logged event: the log is append-only by contract, so
+   * no live reference to logged data leaves this boundary.
+   * @param event - the event to project.
+   * @returns the derived message, or null when the event produces none.
    */
-  private _deriveOneMessage(event: SessionEvent): Message | null {
+  deriveEventMessage(event: SessionEvent): Message | null {
     // Intentionally non-exhaustive: only message-producing events derive
     // history; turn/step boundaries, chunks, usage, and errors are
     // trace/replay data.
@@ -311,8 +354,9 @@ export class Session {
         const { content, source } = event.data
         return { role: 'user', content: renderTagged('steering', structuredClone(content), source) }
       }
-      /* v8 ignore next 2 -- unreachable: only surface nodes (the 5 message-producing types) reach here */
       default:
+        // A non-surface event (boundary, chunk, log-only record) projects to
+        // no message. Merge-extensible union: no assertNever here.
         return null
     }
   }

packages/core/session/src/request-header.ts

@@ -0,0 +1,191 @@
+/**
+ * Request-header reconstruction utilities: the pure fold/diff/apply trio over
+ * the `request/header` / `request/header-delta` session events. Anyone
+ * holding a session log reconstructs the {@link EpochHeader} any request was
+ * built under by folding these events in log order; the loop uses the same
+ * functions to decide whether a step's header changed and to encode the
+ * change. Deltas are an encoding optimization with a safety valve — the
+ * writer round-trip-verifies every delta before appending and falls back to
+ * a full snapshot when the encoding cannot express the change — so folding
+ * never needs error recovery on a well-formed log.
+ *
+ * @module dsh-session/request-header
+ */
+
+import { callConfigEquals } from '@deepseek-ai/dsh-llm'
+import type { LlmCallConfig, ToolSchema } from '@deepseek-ai/dsh-llm'
+import type { EpochHeader, SessionEvent, SystemDelta, ToolsDelta } from './types.ts'
+
+/**
+ * Normalize a header to canonical form: an empty system prompt and an empty
+ * tool list become ABSENT fields, matching how requests are built (both
+ * request-build spreads skip empty values). Diff, fold, and comparison all
+ * operate on canonical headers, so "no system prompt" has exactly one
+ * representation.
+ * @param header - the header to normalize (not mutated).
+ * @returns the canonical header.
+ */
+export function canonicalHeader(header: EpochHeader): EpochHeader {
+  return {
+    config: header.config,
+    ...header.system !== undefined && header.system.length > 0 ? { system: header.system } : {},
+    ...header.tools !== undefined && header.tools.length > 0 ? { tools: header.tools } : {},
+  }
+}
+
+/** Split a canonical (possibly absent) system prompt into lines; absence is zero lines. */
+function systemLines(system: string | undefined): string[] {
+  return system === undefined ? [] : system.split('\n')
+}
+
+/** Join lines back into a canonical system value; zero lines is absence. */
+function joinSystem(lines: string[]): string | undefined {
+  return lines.length === 0 ? undefined : lines.join('\n')
+}
+
+/**
+ * Compute the line-level {@link SystemDelta} between two canonical system
+ * prompts: trim the common prefix and (non-overlapping) common suffix, and
+ * carry the replacement lines between them. Deterministic and library-free;
+ * with nothing shared it degenerates to a full replacement.
+ */
+function diffSystem(prev: string | undefined, next: string | undefined): SystemDelta {
+  const a = systemLines(prev)
+  const b = systemLines(next)
+  let keepStart = 0
+  while (keepStart < a.length && keepStart < b.length && a[keepStart] === b[keepStart]) keepStart += 1
+  let keepEnd = 0
+  while (
+    keepEnd < a.length - keepStart &&
+    keepEnd < b.length - keepStart &&
+    a[a.length - 1 - keepEnd] === b[b.length - 1 - keepEnd]
+  ) keepEnd += 1
+  return { keepStart, keepEnd, insert: b.slice(keepStart, b.length - keepEnd) }
+}
+
+/** Apply a {@link SystemDelta} to a canonical system prompt. */
+function applySystem(prev: string | undefined, delta: SystemDelta): string | undefined {
+  const a = systemLines(prev)
+  return joinSystem([...a.slice(0, delta.keepStart), ...delta.insert, ...a.slice(a.length - delta.keepEnd)])
+}
+
+/** Canonical JSON equality for tool schemas — sound because schemas are
+ * JSON-serializable by construction and both sides come from the same
+ * assembly path, so key insertion order matches when the values do. */
+function sameSchema(a: ToolSchema, b: ToolSchema): boolean {
+  return JSON.stringify(a) === JSON.stringify(b)
+}
+
+/**
+ * Compute the name-keyed {@link ToolsDelta} between two canonical tool lists.
+ * A pure reordering produces an empty delta — the writer's round-trip guard
+ * catches that case and records a snapshot instead.
+ */
+function diffTools(prev: readonly ToolSchema[], next: readonly ToolSchema[]): ToolsDelta {
+  const prevByName = new Map(prev.map(tool => [tool.name, tool]))
+  const nextNames = new Set(next.map(tool => tool.name))
+  return {
+    added: next.filter(tool => !prevByName.has(tool.name)),
+    removed: prev.filter(tool => !nextNames.has(tool.name)).map(tool => tool.name),
+    changed: next.filter((tool) => {
+      const before = prevByName.get(tool.name)
+      return before !== undefined && !sameSchema(before, tool)
+    }),
+  }
+}
+
+/** Apply a {@link ToolsDelta} to a canonical tool list: drop removed, replace changed in place, append added. */
+function applyTools(prev: readonly ToolSchema[], delta: ToolsDelta): ToolSchema[] {
+  const removed = new Set(delta.removed)
+  const changedByName = new Map(delta.changed.map(tool => [tool.name, tool]))
+  const kept = prev
+    .filter(tool => !removed.has(tool.name))
+    .map(tool => changedByName.get(tool.name) ?? tool)
+  return [...kept, ...delta.added]
+}
+
+/**
+ * Field-wise equality over canonical headers — the cheap comparison the
+ * writer's round-trip guard runs (`applyHeaderDelta(prev, delta)` must equal
+ * the intended header) and the loop runs to skip logging an unchanged header.
+ * Tools compare per-schema IN ORDER (canonical JSON), so a pure reordering is
+ * correctly unequal.
+ * @param a - one canonical header.
+ * @param b - the other.
+ * @returns whether config, system, and tools (in order) all match.
+ */
+export function headerEquals(a: EpochHeader, b: EpochHeader): boolean {
+  if (!callConfigEquals(a.config, b.config) || a.system !== b.system) return false
+  const at = a.tools ?? []
+  const bt = b.tools ?? []
+  return at.length === bt.length && at.every((tool, i) => sameSchema(tool, bt[i] as ToolSchema))
+}
+
+/**
+ * Compute the `request/header-delta` payload between two canonical headers,
+ * or undefined when they are equal. The caller MUST round-trip the result
+ * ({@link applyHeaderDelta} on `prev` deep-equals `next`) before logging it —
+ * the encoding cannot express every change (a pure tool reordering) — and
+ * fall back to a full `request/header` snapshot when the check fails.
+ * @param prev - the folded header the log currently implies.
+ * @param next - the header the next request will actually use.
+ * @returns the delta payload, or undefined when nothing changed.
+ */
+export function diffHeader(
+  prev: EpochHeader, next: EpochHeader,
+): { system?: SystemDelta; tools?: ToolsDelta; config?: LlmCallConfig } | undefined {
+  const delta: { system?: SystemDelta; tools?: ToolsDelta; config?: LlmCallConfig } = {}
+  if (prev.system !== next.system) delta.system = diffSystem(prev.system, next.system)
+  const prevTools = prev.tools ?? []
+  const nextTools = next.tools ?? []
+  if (JSON.stringify(prevTools) !== JSON.stringify(nextTools)) delta.tools = diffTools(prevTools, nextTools)
+  if (!callConfigEquals(prev.config, next.config)) delta.config = next.config
+  return Object.keys(delta).length > 0 ? delta : undefined
+}
+
+/**
+ * Apply a `request/header-delta` payload to a canonical header, producing the
+ * canonical header it encodes. Total for well-formed logs (the writer only
+ * appends round-trip-verified deltas).
+ * @param prev - the folded header before the delta.
+ * @param delta - the logged delta payload.
+ * @returns the canonical header after the delta.
+ */
+export function applyHeaderDelta(
+  prev: EpochHeader, delta: { system?: SystemDelta; tools?: ToolsDelta; config?: LlmCallConfig },
+): EpochHeader {
+  const system = delta.system !== undefined ? applySystem(prev.system, delta.system) : prev.system
+  const tools = delta.tools !== undefined ? applyTools(prev.tools ?? [], delta.tools) : prev.tools
+  return canonicalHeader({
+    config: delta.config ?? prev.config,
+    ...system !== undefined ? { system } : {},
+    ...tools !== undefined ? { tools } : {},
+  })
+}
+
+/**
+ * Fold the header events of a log (or any prefix of one) into the
+ * {@link EpochHeader} in force after the last of them: each
+ * `request/header` snapshot replaces the state, each `request/header-delta`
+ * amends it. The pure, offline form of reconstruction — external tooling and
+ * the dev invariant both use it; the live session tracks the same fold
+ * incrementally.
+ * @param events - session events in log order (non-header events are skipped).
+ * @param from - a previously folded state to continue from (the live session's
+ *   incremental cursor); omit to fold from nothing.
+ * @returns the folded header, or undefined when no header event exists yet.
+ */
+export function foldRequestHeader(events: readonly SessionEvent[], from?: EpochHeader): EpochHeader | undefined {
+  let state: EpochHeader | undefined = from
+  for (const event of events) {
+    if (event.type === 'request/header') {
+      state = canonicalHeader(event.data.header)
+    } else if (event.type === 'request/header-delta') {
+      if (state === undefined) {
+        throw new Error(`request/header-delta at seq ${event.seq} before any request/header snapshot: corrupt log`)
+      }
+      state = applyHeaderDelta(state, event.data)
+    }
+  }
+  return state
+}

packages/core/session/src/surface.ts

@@ -72,6 +72,9 @@ export class SurfaceManager {
   /** The last processed seq. -1 forces a full rebuild on first access. */
   private _lastProcessedSeq = -1
 
+  /** Rewrite generation — see {@link replaceGeneration}. */
+  private _replaceGeneration = 0
+
   constructor(private log: readonly SessionEvent[]) {}
 
   /**
@@ -83,6 +86,23 @@ export class SurfaceManager {
     this._lastProcessedSeq = -1
     this._nodes = []
     this._nodeBySeq.clear()
+    // A wholesale rebuild is a rewrite: bump the generation so incremental
+    // consumers (the session's derived-message cache) discard their view.
+    this._replaceGeneration += 1
+  }
+
+  /**
+   * The surface's rewrite generation: bumped by every folded `replace` op and
+   * by {@link invalidate}. A replace is the ONE operation that rewrites the
+   * surface non-monotonically, so an incremental consumer of {@link nodes}
+   * (the session's derived-message cache) compares this between visits — an
+   * unchanged generation guarantees every node it has not seen is a pure tail
+   * append; a changed one means its view must rebuild. Monotonic: it never
+   * moves backwards, so comparisons cannot be fooled by a re-fold.
+   */
+  get replaceGeneration(): number {
+    if (this._lastProcessedSeq < this.log.length - 1) this._processDelta()
+    return this._replaceGeneration
   }
 
   /** The surface nodes in linked-list order (head to tail). */
@@ -155,5 +175,6 @@ export class SurfaceManager {
     if (nextNode) nextNode.prev = newSeq
     this._nodes.splice(startIdx, 0, newNode)
     this._nodeBySeq.set(newSeq, newNode)
+    this._replaceGeneration += 1
   }
 }

packages/core/session/src/types.ts

@@ -1,5 +1,5 @@
 import type { Branded } from '@deepseek-ai/dsh-brand'
-import type { CallId, ContentBlock, MessageSource, StreamChunk, TokenUsage } from '@deepseek-ai/dsh-llm'
+import type { CallId, ContentBlock, LlmCallConfig, MessageSource, StreamChunk, TokenUsage, ToolSchema } from '@deepseek-ai/dsh-llm'
 
 /** Identifies one session in the store (and its persistence artifacts). */
 export type SessionId = Branded<'SessionId'>
@@ -176,6 +176,67 @@ export interface TodoItem {
   status: 'pending' | 'in_progress' | 'completed'
 }
 
+/**
+ * The request header: everything about an LLM request besides its message
+ * content — the call configuration plus the rendered system prompt and tool
+ * schemas. Logged session state (the reconstructability RFC): a
+ * {@link SessionEventMap} `request/header` snapshot installs one, a
+ * `request/header-delta` amends it, and folding those events over the log
+ * (`foldRequestHeader`) reconstructs the header any request was built under.
+ * Canonical form: an empty system prompt and an empty tool list are ABSENT
+ * fields, matching how requests are built.
+ */
+export interface EpochHeader {
+  /** The conversation's call configuration (model + sampling scalars). */
+  config: LlmCallConfig
+  /** Rendered system prompt text; absent for a system-less request. */
+  system?: string
+  /** Assembled tool schemas; absent for a tool-less request. */
+  tools?: ToolSchema[]
+}
+
+/**
+ * Why a `request/header` snapshot was appended: `'initial'` — the log's first
+ * header (a new conversation); `'resume'` — a loop instance's first request
+ * over a log that already has header events (process restart, fork seed);
+ * `'fallback'` — a mid-run change the delta encoding could not round-trip
+ * (e.g. a pure tool reordering), recorded whole instead.
+ */
+export type RequestHeaderReason = 'initial' | 'resume' | 'fallback'
+
+/**
+ * Line-level edit of the system prompt: keep the first `keepStart` and last
+ * `keepEnd` lines of the previous text, with `insert` replacing everything
+ * between. Computed as a common-prefix/common-suffix trim — deterministic,
+ * library-free, degenerating to a full replacement when nothing is shared.
+ * Absence is encoded as zero lines (the canonical form has no empty-string
+ * system), so a transition to or from "no system prompt" round-trips.
+ */
+export interface SystemDelta {
+  /** Lines kept from the start of the previous system prompt. */
+  keepStart: number
+  /** Lines kept from the end of the previous system prompt. */
+  keepEnd: number
+  /** Lines replacing everything between the kept edges. */
+  insert: string[]
+}
+
+/**
+ * Tool-set edit keyed by tool name (names are unique — the registry rejects
+ * duplicates): `removed` names drop, `changed` schemas replace their
+ * predecessor in place, `added` schemas append at the end. A change this
+ * encoding cannot express (a pure reordering) fails the writer's round-trip
+ * guard and is recorded as a `'fallback'` snapshot instead.
+ */
+export interface ToolsDelta {
+  /** Schemas appended to the end of the tool list. */
+  added: ToolSchema[]
+  /** Names of schemas dropped from the tool list. */
+  removed: string[]
+  /** Schemas replacing the same-named predecessor in place. */
+  changed: ToolSchema[]
+}
+
 /**
  * The session event vocabulary — the append-only source of truth for an
  * agent's whole interaction history. The LLM message history is *derived*
@@ -274,6 +335,30 @@ export interface SessionEventMap {
    * cordis-catalog row.
    */
   'todo/write': { todos: TodoItem[] }
+  /**
+   * Full snapshot of the {@link EpochHeader} the NEXT request is built under,
+   * with the {@link RequestHeaderReason} it was recorded whole. Appended by
+   * the loop inside the step, before dispatch, on a loop instance's first
+   * request-building step (`'initial'`/`'resume'`) or when a delta failed its
+   * round-trip guard (`'fallback'`); always records what the request actually
+   * used, post-`agent/request`. Anchors the header fold: reconstruction reads
+   * the latest snapshot and applies the deltas after it. NOT a
+   * {@link SurfaceEventType}: it produces no LLM message — it is the request
+   * envelope, logged so every request is a pure function of the session log
+   * (the reconstructability RFC).
+   */
+  'request/header': { header: EpochHeader; reason: RequestHeaderReason }
+  /**
+   * Amendment to the folded {@link EpochHeader}: at least one of a
+   * {@link SystemDelta}, a {@link ToolsDelta}, or a whole replacement
+   * {@link LlmCallConfig} (four scalars — not worth diffing). Appended by the
+   * loop inside the step, before dispatch, when the header for this request
+   * differs from the fold of the log so far; the writer verifies
+   * `applyHeaderDelta(previous, delta)` reproduces the new header exactly and
+   * falls back to a `'fallback'` `request/header` snapshot when it cannot, so
+   * a logged delta ALWAYS round-trips. NOT a {@link SurfaceEventType}.
+   */
+  'request/header-delta': { system?: SystemDelta; tools?: ToolsDelta; config?: LlmCallConfig }
 }
 
 export type SessionEventType = keyof SessionEventMap