dsh-context-fold 0.0.0-stage → 0.1.1

package/lib/index.d.ts

@@ -0,0 +1,663 @@
+import z from "@deepseek-ai/schemastery";
+import { Session, SessionEvent, SessionSeq } from "@deepseek-ai/dsh-session";
+import { AssistantMessage, ContentBlock, Message } from "@deepseek-ai/dsh-llm";
+import { Context } from "@deepseek-ai/cordis";
+import { SessionMessageProjectionContext } from "@deepseek-ai/dsh-session/surface";
+import { SpillStore } from "@deepseek-ai/dsh-spill";
+/** Resolved, validated fold budgets. */
+interface ContextFoldConfig {
+  /** Skip results smaller than this many characters. Never below 300 (design §3.4: negative return below that). */
+  minFoldChars: number;
+  /** Only fold when the candidate batch is worth the one cache invalidation. */
+  minBatchChars: number;
+  /** Never fold the newest N steps. */
+  keepRecentSteps: number;
+  /** Age condition that lets a single long turn fold without a turn boundary. */
+  staleSteps: number;
+  /** Split a very long turn into contiguous step ranges of this size. */
+  batchSpanSteps: number;
+  /** Fold reasoning blocks on historical tool-call turns (phase 2). */
+  foldReasoning: boolean;
+  /**
+   * Also fold reasoning on plain (non-tool-call) turns.
+   *
+   * Off by default because `dsh-llm-deepseek` drops plain-turn reasoning, so on
+   * that route folding it saves nothing. Turn it on for a route whose serializer
+   * re-sends plain-turn reasoning unconditionally (e.g. `dsh-router-core`), where
+   * it is a real saving.
+   */
+  foldPlainTurnReasoning: boolean;
+  /** Master switch; `false` means the plugin does nothing at all. */
+  enabled: boolean;
+  /** Compute and report candidates without mutating anything. */
+  dryRun: boolean;
+}
+/** Low-friction defaults from design §6.9. */
+declare const DEFAULT_CONFIG: Readonly<ContextFoldConfig>;
+/** Config schema shown in the settings UI. */
+declare const Config: z<Schemastery.ObjectS<NoInfer<{
+  minFoldChars: z<number, number, "defined">;
+  minBatchChars: z<number, number, "defined">;
+  keepRecentSteps: z<number, number, "defined">;
+  staleSteps: z<number, number, "defined">;
+  batchSpanSteps: z<number, number, "defined">;
+  foldReasoning: z<boolean, boolean, "defined">;
+  foldPlainTurnReasoning: z<boolean, boolean, "defined">;
+  enabled: z<boolean, boolean, "defined">;
+  dryRun: z<boolean, boolean, "defined">;
+}>>, Schemastery.ObjectT<NoInfer<{
+  minFoldChars: z<number, number, "defined">;
+  minBatchChars: z<number, number, "defined">;
+  keepRecentSteps: z<number, number, "defined">;
+  staleSteps: z<number, number, "defined">;
+  batchSpanSteps: z<number, number, "defined">;
+  foldReasoning: z<boolean, boolean, "defined">;
+  foldPlainTurnReasoning: z<boolean, boolean, "defined">;
+  enabled: z<boolean, boolean, "defined">;
+  dryRun: z<boolean, boolean, "defined">;
+}>>, "plain">;
+/**
+ * Resolve and validate a partly-specified configuration.
+ *
+ * @param config - raw plugin configuration.
+ * @returns a detached, frozen configuration.
+ * @throws when a budget is not a safe integer or `minFoldChars` is below 300.
+ */
+declare function resolveConfig(config?: Partial<ContextFoldConfig>): ContextFoldConfig;
+/** One candidate result as the rules see it. */
+interface FoldFacts {
+  /** Tool name from the paired `tool/call`. */
+  toolName: string;
+  /** The result's model-issued call id. */
+  callId: string;
+  /** Current model-visible content of the result. */
+  content: readonly ContentBlock[];
+  /** Raw `arguments` JSON of the paired `tool/call`, when that event is still present. */
+  args?: string;
+  /** Whole-result character count under {@link codePointLength}. */
+  chars: number;
+}
+/** Parsed spill notice: where the full text already lives. */
+interface SpillNotice {
+  locator: string;
+  bytes: number | undefined;
+}
+/**
+ * Count Unicode code points without splitting surrogate pairs, matching the
+ * pruner's measurement so sizes are comparable across plugins.
+ *
+ * @param text - text to measure.
+ * @returns the code-point count.
+ */
+declare function codePointLength(text: string): number;
+/**
+ * Model-visible text of one result, including image/file placeholders.
+ *
+ * @param content - ordered result blocks.
+ * @returns concatenated text with a stable placeholder for non-text blocks.
+ */
+declare function textOf(content: readonly ContentBlock[]): string;
+/**
+ * Whether a result can be folded without losing anything structural.
+ *
+ * Image and unknown blocks are never folded: their placeholder text is not the
+ * content, and phase 1 must not trade an attachment for a sentence about it.
+ *
+ * @param content - ordered result blocks.
+ * @returns true when every block is text.
+ */
+declare function isFoldableContent(content: readonly ContentBlock[]): boolean;
+/**
+ * Find the spill notice an already-bounded result carries, so folding reuses
+ * that locator instead of spilling the same text twice (design §6.5).
+ *
+ * @param text - result text.
+ * @returns the parsed notice, or undefined when the result was never spilled.
+ */
+declare function parseSpillNotice(text: string): SpillNotice | undefined;
+/**
+ * Produce the one-line conclusion for a result.
+ *
+ * The rule is chosen by tool family, mirroring design §6.3, and falls back to
+ * the first line plus a size for anything unlisted. A conclusion is always
+ * shorter than the result it replaces; callers still compare sizes before
+ * folding, because a pathological result can defeat any rule.
+ *
+ * @param facts - candidate facts.
+ * @returns the conclusion body (without the fold header), or undefined when the
+ *   result carries no foldable text.
+ */
+declare function conclude(facts: FoldFacts): string | undefined;
+/** One model-visible `tool/result` node at evaluation time. */
+interface NodeSnapshot {
+  /** Current surface sequence number. */
+  seq: SessionSeq;
+  /** Turn the result belongs to. */
+  turn: number;
+  /** Step the result belongs to. */
+  step: number;
+  /** Tool name, resolved from the paired `tool/call` when that event is still reachable. */
+  toolName: string;
+  /** Model-issued call id. */
+  callId: string;
+  /** Raw `arguments` JSON of the paired `tool/call`, when available. */
+  args?: string;
+  /** Current model-visible content. */
+  content: readonly ContentBlock[];
+  /** Whether the tool invocation failed. */
+  isError: boolean;
+}
+/** One searchable later event used by reference detection (design §6.2). */
+interface MentionRecord {
+  /** Event sequence number. */
+  seq: number;
+  /** Text searched for a candidate's call id. */
+  text: string;
+}
+/** The complete input to one evaluation. */
+interface PlanInput {
+  /** Current surface `tool/result` nodes, in surface order. */
+  nodes: readonly NodeSnapshot[];
+  /** Later events whose text can cite a call id: tool-call arguments and message text. */
+  mentions: readonly MentionRecord[];
+  /** Turn being evaluated (the open turn). */
+  currentTurn: number;
+  /** Step being evaluated: the step about to run, or the closing step. */
+  currentStep: number;
+  /** Resolved configuration. */
+  config: ContextFoldConfig;
+}
+/** One planned fold, independent of any spill locator. */
+interface FoldPlan {
+  /** Surface seq of the node to rewrite. */
+  seq: SessionSeq;
+  /** Detached facts of the node. */
+  facts: FoldFacts;
+  /** The node's turn. */
+  turn: number;
+  /** The node's step. */
+  step: number;
+  /** Conclusion body that will be rendered inline. */
+  conclusion: string;
+  /** Full current text to persist before the rewrite. */
+  original: string;
+  /** Whether this node carries the batch roster. */
+  head: boolean;
+  /** The head's call id, present on non-head members. */
+  headCallId?: string;
+}
+/** One batch of folds sharing a turn and a contiguous step range. */
+interface FoldBatch {
+  /** Stable batch key (`turn:stepFrom-stepTo`), used only for reporting. */
+  key: string;
+  /** The batch head's call id. */
+  callId: string;
+  /** Members in fold order (largest first). */
+  members: readonly FoldPlan[];
+  /** Original character count of the batch. */
+  chars: number;
+}
+/** Why one node did not fold, for the dry-run report. */
+interface SkippedNode {
+  /** Surface seq. */
+  seq: SessionSeq;
+  /** Tool name. */
+  toolName: string;
+  /** Character count. */
+  chars: number;
+  /** Machine-readable reason. */
+  reason: 'recent' | 'alive' | 'referenced' | 'error' | 'folded' | 'small' | 'unfoldable' | 'no-conclusion';
+}
+/** The complete result of one evaluation. */
+interface FoldDecision {
+  /** Batches to fold, in fold order. */
+  batches: readonly FoldBatch[];
+  /** Nodes considered and rejected, for diagnostics and the dry-run report. */
+  skipped: readonly SkippedNode[];
+  /** Total character count of every candidate that qualified, before batching. */
+  candidateChars: number;
+}
+/**
+ * Decide what to fold for one snapshot.
+ *
+ * Candidate rules, in the order they are checked (design §6.1): error results
+ * never fold, recently-used results never fold, already-folded nodes never
+ * fold, nodes still cited by a later event never fold, and a node folds only
+ * when it is at least `minFoldChars` and a conclusion exists that is smaller
+ * than the result.
+ *
+ * @param input - one detached snapshot plus configuration.
+ * @returns the decision; an empty `batches` array means "do nothing".
+ */
+declare function planFolds(input: PlanInput): FoldDecision;
+/** Fixed prefix identifying a folded node. A `startsWith` test is the idempotency check. */
+declare const FOLD_MARKER = "[context-fold]";
+/**
+ * Whether already-folded content is being inspected.
+ *
+ * @param text - current model-visible text of a node.
+ * @returns true when the node is a fold this plugin produced.
+ */
+declare function isFoldedText(text: string): boolean;
+/** Marker opening a folded reasoning block. Must be distinctive: `startsWith` is the idempotency test. */
+declare const REASONING_MARKER = "[context-fold] [reasoning]";
+/** Durable record type carrying one reasoning-fold decision. */
+declare const REASONING_EVENT = "plugin:context-fold/reasoning";
+/** One reasoning fold recorded by a decision record. */
+interface ReasoningTarget {
+  /** Surface seq of the assistant node whose reasoning is folded. */
+  seq: SessionSeq;
+  /** Content indexes of the folded reasoning blocks, in content order. */
+  indexes: readonly number[];
+  /** Original code-point length of each folded block, for the report. */
+  chars: readonly number[];
+  /** Spill locator per folded block, parallel to `indexes`. Absent when spilling failed. */
+  locators?: readonly (string | undefined)[];
+}
+/** Data of one `plugin:context-fold/reasoning` decision record. */
+interface ReasoningFoldData {
+  /** Targets, in surface order. */
+  targets: readonly ReasoningTarget[];
+}
+/**
+ * Declare the durable decision record.
+ *
+ * This uses {@link PluginRecordMap}, **not** `SessionEventMap`. That distinction
+ * is load-bearing and was initially got wrong here:
+ *
+ * A `SessionEventMap` augmentation only adds a *TypeScript* type. The record
+ * written by `session.append()` carries an envelope of exactly
+ * `{type, seq, time, data}` with **no `ignorable` marker**, and the persistence
+ * read path refuses any type outside `KNOWN_SESSION_EVENT_TYPES` unless
+ * `ignorable === true`:
+ *
+ * > "contains event type … unknown to this harness and not marked ignorable;
+ * > refusing to interpret the log"
+ * > — `dsh-session-persistence` `assertEventsSupported`
+ *
+ * So a plain `append` of a plugin-invented type makes the session **unreopenable**,
+ * which would lose the whole conversation. `appendPluginRecord` is the host's
+ * sanctioned alternative: it stamps `ignorable: true`, and a reader that does not
+ * know the type retains and skips it.
+ *
+ * `dsh-compaction-image-offload` is *not* a precedent for the other approach,
+ * because `image/offload` is a harness-core member of
+ * `KNOWN_SESSION_EVENT_TYPES`; a downstream plugin cannot join that set.
+ */
+declare module '@deepseek-ai/dsh-session/types' {
+  interface PluginRecordMap {
+    /**
+     * Fold historical reasoning blocks on tool-call turns.
+     *
+     * Targets name current `assistant/message` surface nodes and the content
+     * indexes of the reasoning blocks the decision covers. Message identity,
+     * block count, and block types are preserved; the durable assistant event
+     * keeps the full original text.
+     */
+    'plugin:context-fold/reasoning': ReasoningFoldData;
+  }
+}
+/**
+ * Whether a reasoning block is already folded.
+ *
+ * @param text - reasoning text.
+ * @returns true for a block this plugin produced.
+ */
+declare function isFoldedReasoning(text: string): boolean;
+/**
+ * Whether a message is a tool-call turn, i.e. a turn that requested tool work.
+ *
+ * This is a **policy** filter, not a token-accounting claim. Reasoning is re-sent
+ * differently per route:
+ *
+ * - `dsh-llm-deepseek`'s `serializeAssistant` emits `reasoning_content` only when
+ *   `toolCalls.length > 0` ("it is ignored on plain turns, so we drop it there"),
+ *   so a plain turn's reasoning is free on that route.
+ * - `dsh-router-core`'s `wireMessages` — the route this profile actually runs —
+ *   does **not** gate it: `...reasoning.length > 0 ? { reasoning_content } : {}`
+ *   is unconditional, so plain-turn reasoning IS re-sent and does cost tokens.
+ *
+ * Restricting to tool-call turns therefore leaves real bytes on the table on the
+ * router route. It stays the default only because the conservative shape matches
+ * phase 1's "completed stage" intent and the measured tool-call share dominates;
+ * `foldPlainTurnReasoning` widens it for routes that replay plain-turn reasoning.
+ *
+ * @param content - assistant content blocks.
+ * @returns true when the message carries at least one tool call.
+ */
+declare function isToolCallTurn(content: readonly ContentBlock[]): boolean;
+/**
+ * Build the replacement text for one reasoning block.
+ *
+ * The head is preserved verbatim, so no information is invented and the
+ * conclusion-like opening of the thought stays visible. The character count and
+ * the full-length note make the omission visible, which is the difference
+ * between a cautious model and a fluent one.
+ *
+ * When a `locator` is supplied the folded text inlines it, so the omission is
+ * **recoverable**: `read`/`grep` on that path returns the original reasoning.
+ * Without it the note is a pointer to nothing — it tells the model detail is
+ * missing while offering no way to fetch it — which is why the fold path always
+ * tries to spill first (design §12.7).
+ *
+ * @param text - original reasoning text.
+ * @param locator - spill path holding the full original, when one was written.
+ * @returns folded text, or undefined when folding would not shorten it.
+ */
+declare function foldReasoningText(text: string, locator?: string): string | undefined;
+/** One candidate assistant node for reasoning folding. */
+interface ReasoningCandidate {
+  /** Current surface seq. */
+  seq: SessionSeq;
+  /** Turn the message belongs to. */
+  turn: number;
+  /** Step the message belongs to. */
+  step: number;
+  /** Current model-visible content. */
+  content: readonly ContentBlock[];
+}
+/** One planned reasoning fold. */
+interface ReasoningPlan {
+  /** Surface seq to project. */
+  seq: SessionSeq;
+  /** Folded block indexes, in content order. */
+  indexes: readonly number[];
+  /** Original character count per folded block. */
+  chars: readonly number[];
+  /** Total characters removed. */
+  charsRemoved: number;
+  /**
+   * Spill locators parallel to `indexes`: where each block's full original lives.
+   *
+   * The record carries these so the projection can inline the same recovery path
+   * on replay; without them a restored session would show an omission note with
+   * no way to recover the text.
+   */
+  locators?: readonly (string | undefined)[];
+}
+/**
+ * Plan reasoning folds for one snapshot.
+ *
+ * A node qualifies when it is a tool-call turn (where reasoning is re-sent most,
+ * and where the measurable win is), when it is old enough by the same age rules
+ * phase 1 uses, and when at least one reasoning block is large enough to shrink.
+ *
+ * The plan itself does not spill: writing to the store is side-effectful, so it
+ * happens in `recordReasoningFolds`, which fills in the locators and re-derives
+ * the conclusion text with them.
+ *
+ * @param candidates - current assistant nodes, in surface order.
+ * @param currentTurn - turn being evaluated.
+ * @param currentStep - step being evaluated.
+ * @param config - resolved configuration.
+ * @returns plans in surface order.
+ */
+declare function planReasoningFolds(candidates: readonly ReasoningCandidate[], currentTurn: number, currentStep: number, config: ContextFoldConfig): ReasoningPlan[];
+/**
+ * Project one assistant message with selected reasoning blocks folded.
+ *
+ * Message identity and every other block are preserved verbatim, which is what
+ * `replayedAssistant` and `foreignAssistant` both require: the block count and
+ * block types are unchanged, so even a signed route would still validate.
+ *
+ * @param message - message to project.
+ * @param indexes - reasoning block indexes to fold, strictly increasing.
+ * @returns an immutable projected copy.
+ * @throws when an index is out of range or does not name a reasoning block.
+ */
+declare function projectReasoning(message: AssistantMessage, indexes: readonly number[], locators?: readonly (string | undefined)[]): AssistantMessage;
+/**
+ * Collect the assistant nodes a decision event may target.
+ *
+ * @param session - session to read.
+ * @returns candidates in surface order.
+ */
+declare function reasoningCandidates(session: Session): ReasoningCandidate[];
+/**
+ * Append one decision record covering the planned folds.
+ *
+ * The record is self-describing: it stores the exact content indexes it covers,
+ * so replay never has to re-derive *which* blocks were chosen from a count. The
+ * record is durable and pure — replaying the log through the registered
+ * projection reproduces exactly the same request content.
+ *
+ * @param session - session to extend.
+ * @param plans - folds to record.
+ * @param spill - optional spill store; when supplied, every folded block's full
+ *   text is written first and its locator is recorded so the projection can
+ *   inline a real recovery path.
+ * @returns the record's sequence number.
+ */
+declare function recordReasoningFolds(session: Session, plans: readonly ReasoningPlan[], spill?: ReasoningSpill): Promise<SessionSeq>;
+/**
+ * The slice of the spill store this module needs.
+ *
+ * Typed against the host's own `SpillStore` rather than a hand-written shape:
+ * its ids are branded (`SessionId`, `ToolCallId`), so a local structural type
+ * would either fail to accept the real store or force a cast.
+ */
+type ReasoningSpill = {
+  saveText(input: SpillStore['saveText'] extends ((input: infer I) => Promise<unknown>) ? I : never): Promise<{
+    locator: string;
+  }>;
+};
+/**
+ * The projection definition registered with `ctx.sessions`.
+ *
+ * It is deliberately **tolerant of stale targets** rather than strict: a
+ * decision is durable, but the surface it referred to is not frozen — a
+ * `compaction` replacement can remove a node the decision named. Throwing there
+ * would make every later `deriveMessages()` fail and brick the session, which
+ * violates the design's "a session never errors" anti-goal. A target whose node
+ * is no longer current, or whose reasoning blocks are already folded, is
+ * therefore skipped: the fold it described is simply no longer applicable.
+ *
+ * Each target's `chars` array is only a length hint — how many reasoning blocks
+ * that decision intended to fold. The projection folds that many still-unfolded
+ * reasoning blocks, which keeps replay correct even after a later decision has
+ * already folded a sibling block.
+ */
+/**
+ * The projection definition registered with `ctx.sessions`.
+ *
+ * **Why a cast is needed, and why it is correct:** `SessionMessageProjection<T>`
+ * constrains `T extends keyof SessionEventMap`, so the host's *types* do not
+ * admit a `plugin:` record type. The *runtime* does: `SurfaceManager` resolves a
+ * projection with `projections.find(item => item.type === event.type)` **before**
+ * it looks at `surfaceOp`, so any committed event type can drive one. The cast is
+ * therefore only widening a compile-time parameter that the implementation
+ * already accepts.
+ *
+ * A projection must **not** be registered for a surface event type
+ * (`assistant/message`, `user/message`, `tool/result`): `planSurfaceEvent`
+ * returns a `project` plan *instead of* an append/replace plan, and
+ * `applySurfacePlan` only pushes nodes for `append`, so such a registration would
+ * silently drop every message of that type off the surface. A non-surface
+ * plugin-owned record is the only correct carrier.
+ *
+ * It is deliberately **tolerant of stale targets** rather than strict: a
+ * decision is durable, but the surface it referred to is not frozen — a
+ * `compaction` replacement can remove a node the decision named. Throwing there
+ * would make every later derivation fail and brick the session, which violates
+ * the design's "a session never errors" anti-goal.
+ */
+declare const reasoningProjection: {
+  readonly type: "plugin:context-fold/reasoning";
+  readonly project: (event: SessionEvent, context: SessionMessageProjectionContext) => ReadonlyMap<SessionSeq, Message>;
+};
+/** One landed fold, for the measurement record. */
+interface FoldedNodeRecord {
+  /** Seq of the replacement node. */
+  replacementSeq: number;
+  /** Seq of the replaced node. */
+  originalSeq: number;
+  /** Tool call id. */
+  callId: string;
+  /** Tool name. */
+  toolName: string;
+  /** Characters before. */
+  charsBefore: number;
+  /** Characters after. */
+  charsAfter: number;
+  /** Where the full original lives. */
+  locator: string;
+  /** Bytes written to the spill store by this fold (0 when an existing spill was reused). */
+  spillBytes: number;
+}
+/** One failed fold; earlier folds of the pass stay durable. */
+interface FoldFailure {
+  /** Seq of the node that could not be folded. */
+  seq: number;
+  /** Tool name, when known. */
+  toolName: string;
+  /** Human-readable cause. */
+  reason: string;
+}
+/** Result of one fold pass. */
+interface FoldPassResult {
+  /** The decision this pass acted on. */
+  decision: FoldDecision;
+  /** Landed folds, in fold order. */
+  folded: readonly FoldedNodeRecord[];
+  /** Nodes that failed, in fold order. */
+  failed: readonly FoldFailure[];
+  /** Characters removed from the surface by this pass. */
+  charsRemoved: number;
+}
+/**
+ * Build the detached evaluation input for one moment in the session.
+ *
+ * Surface seqs are always sourced fresh from `session.surface.nodes`, never
+ * cached across evaluations (design §6.7), because a replacement splices the new
+ * seq over the old one and the old seq leaves the surface.
+ *
+ * @param session - session to read.
+ * @returns a snapshot that does not reference live session objects.
+ */
+declare function snapshotInput(session: Session): {
+  nodes: NodeSnapshot[];
+  mentions: MentionRecord[];
+};
+/**
+ * Plan one evaluation without touching the session.
+ *
+ * @param session - session to read.
+ * @param currentTurn - the turn being evaluated.
+ * @param currentStep - the step being evaluated.
+ * @param config - resolved configuration.
+ * @returns the decision.
+ */
+declare function planFor(session: Session, currentTurn: number, currentStep: number, config: ContextFoldConfig): FoldDecision;
+/** One fold found in the log. */
+interface FoldRecord {
+  /** Seq of the replacement node. */
+  seq: number;
+  /** Turn the folded result belonged to. */
+  turn: number;
+  /** Step the folded result belonged to. */
+  step: number;
+  /** Tool name parsed from the marker line. */
+  toolName: string;
+  /** Original character count parsed from the marker line. */
+  charsBefore: number;
+  /** Current character count of the folded node. */
+  charsAfter: number;
+  /** Sequential calls later found that cite this fold's call id. */
+  reReads: number;
+  /** Whether this node is a batch head. */
+  head: boolean;
+}
+/** Aggregate facts about one session's folds. */
+interface FoldReport {
+  /** Every fold currently on the surface, in surface order. */
+  folds: readonly FoldRecord[];
+  /** Characters removed across the surface. */
+  charsRemoved: number;
+  /** Total sequential references to folded content. */
+  reReads: number;
+  /** How many of the folds were cited at least once. */
+  rereadNodes: number;
+  /** Reasoning folds recorded by decision events (phase 2). */
+  reasoningFolds: readonly ReasoningFoldRecord[];
+}
+/** One reasoning fold found in the log. */
+interface ReasoningFoldRecord {
+  /** Message surface seq the decision named. */
+  seq: number;
+  /** Reasoning blocks the decision covered. */
+  blocks: number;
+  /** Original characters in those blocks. */
+  charsBefore: number;
+  /** Characters the projected text currently occupies. */
+  charsAfter: number;
+}
+/**
+ * Derive a report from one session's current log.
+ *
+ * @param session - session to inspect.
+ * @returns the fold report.
+ */
+declare function reportOf(session: Session): FoldReport;
+/**
+ * Render the `/context-fold` report.
+ *
+ * @param report - derived report.
+ * @param dryRun - whether the plugin is configured to mutate nothing.
+ * @returns markdown text for the command result.
+ */
+declare function renderReport(report: FoldReport, dryRun: boolean): string;
+/** Cordis plugin identity. */
+declare const name = "context-fold";
+/** The plugin needs a token meter; without a spill store it no-ops with a warning (design §6.5). */
+declare const inject: string[];
+/**
+ * Mount the fold policy.
+ *
+ * @param ctx - plugin context.
+ * @param rawConfig - configuration from the settings row.
+ */
+declare function apply(ctx: Context, rawConfig?: Partial<ContextFoldConfig>): void;
+/**
+ * One-line summary of a decision for the log during `dryRun`.
+ *
+ * @param prefix - leading phrase.
+ * @param decision - the decision to describe.
+ * @param config - resolved configuration.
+ * @returns a single log line.
+ */
+declare function describeDecision(prefix: string, decision: {
+  batches: readonly {
+    members: readonly unknown[];
+  }[];
+  candidateChars: number;
+  skipped: readonly {
+    reason: string;
+  }[];
+}, config: ContextFoldConfig): string;
+declare const _default: {
+  name: string;
+  inject: string[];
+  Config: import("@deepseek-ai/schemastery").default<Schemastery.ObjectS<NoInfer<{
+    minFoldChars: import("@deepseek-ai/schemastery").default<number, number, "defined">;
+    minBatchChars: import("@deepseek-ai/schemastery").default<number, number, "defined">;
+    keepRecentSteps: import("@deepseek-ai/schemastery").default<number, number, "defined">;
+    staleSteps: import("@deepseek-ai/schemastery").default<number, number, "defined">;
+    batchSpanSteps: import("@deepseek-ai/schemastery").default<number, number, "defined">;
+    foldReasoning: import("@deepseek-ai/schemastery").default<boolean, boolean, "defined">;
+    foldPlainTurnReasoning: import("@deepseek-ai/schemastery").default<boolean, boolean, "defined">;
+    enabled: import("@deepseek-ai/schemastery").default<boolean, boolean, "defined">;
+    dryRun: import("@deepseek-ai/schemastery").default<boolean, boolean, "defined">;
+  }>>, Schemastery.ObjectT<NoInfer<{
+    minFoldChars: import("@deepseek-ai/schemastery").default<number, number, "defined">;
+    minBatchChars: import("@deepseek-ai/schemastery").default<number, number, "defined">;
+    keepRecentSteps: import("@deepseek-ai/schemastery").default<number, number, "defined">;
+    staleSteps: import("@deepseek-ai/schemastery").default<number, number, "defined">;
+    batchSpanSteps: import("@deepseek-ai/schemastery").default<number, number, "defined">;
+    foldReasoning: import("@deepseek-ai/schemastery").default<boolean, boolean, "defined">;
+    foldPlainTurnReasoning: import("@deepseek-ai/schemastery").default<boolean, boolean, "defined">;
+    enabled: import("@deepseek-ai/schemastery").default<boolean, boolean, "defined">;
+    dryRun: import("@deepseek-ai/schemastery").default<boolean, boolean, "defined">;
+  }>>, "plain">;
+  apply: typeof apply;
+};
+export { Config, type ContextFoldConfig, DEFAULT_CONFIG, FOLD_MARKER, type FoldBatch, type FoldDecision, type FoldFacts, type FoldFailure, type FoldPassResult, type FoldPlan, type FoldRecord, type FoldReport, type FoldedNodeRecord, type NodeSnapshot, REASONING_EVENT, REASONING_MARKER, type ReasoningCandidate, type ReasoningFoldData, type ReasoningPlan, type ReasoningTarget, type SkippedNode, apply, codePointLength, conclude, _default as default, describeDecision, foldReasoningText, inject, isFoldableContent, isFoldedReasoning, isFoldedText, isToolCallTurn, name, parseSpillNotice, planFolds, planFor, planReasoningFolds, projectReasoning, reasoningCandidates, reasoningProjection, recordReasoningFolds, renderReport, reportOf, resolveConfig, snapshotInput, textOf };