billion-context-dsh 0.2.21 → 0.2.22

package/dist/settings.d.ts

@@ -0,0 +1,157 @@
+/**
+ * M6 — runtime settings integration. Wires the engine's scalar knobs into the
+ * host's user-settings layer (`~/.dsh/settings.yaml`, section
+ * `compaction-acp`) through the official consumer seam
+ * `SettingsProvider.installSection` (@deepseek-ai/dsh-settings), so editing the file
+ * applies to RUNNING sessions without a restart.
+ *
+ * Layering (per key): schemastery schema default → composition-row subset
+ * (the `base` layer, filtered by `filterSettingsEntry`) → user section.
+ * The `/acp config` slash command reads and writes the same namespace
+ * through the `SettingsCommandSurface` built here.
+ *
+ * Deliberately NOT exposed through settings: `coreOverrides`, `countTokens`,
+ * `autoTools`, `autoCommand`, `prompts` (object/function values or
+ * construction-time registrations), and the `settingsEnabled` kill switch
+ * itself (a switch that turns off its own plumbing could not be reached if
+ * the plumbing broke).
+ * @module billion-context-dsh/settings
+ */
+import z from '@deepseek-ai/schemastery';
+import type { SettingsDescriptor, SettingsProvider } from '@deepseek-ai/dsh-settings';
+/**
+ * The host settings namespace — same id as the bundle/composition row, so "the
+ * settings.yaml section" and "the cordis.patch.yml row" are one mental object.
+ * A plain string literal as of the 0.1.5 line: the seam's `settingsNamespace()`
+ * runtime helper is gone and the brand is applied at the call site instead
+ * (`installSection`'s `Namespace & SettingsNamespaceInput<Namespace>`).
+ */
+export declare const ACP_SETTINGS_NAMESPACE = "compaction-acp";
+/** The six knobs exposed to the runtime settings layer. Order defines /acp config listing order. */
+export declare const SETTINGS_KEYS: readonly ['modelContextLimit', 'autoModelContextLimit', 'nudgeMinContextLimitPct', 'nudgeMaxContextLimitPct', 'nudgeEmergencyThresholdPct', 'autoNudge'];
+export type SettingsKey = (typeof SETTINGS_KEYS)[number];
+/** Resolved shape of one settings snapshot — what every consumer read returns. */
+export interface AcpSettings {
+    /** Absent = auto-detection mode (probe the model's real window). */
+    readonly modelContextLimit?: number;
+    readonly autoModelContextLimit: boolean;
+    /** Absent = the kernel's own 0.45 floor stays in effect. */
+    readonly nudgeMinContextLimitPct?: number;
+    readonly nudgeMaxContextLimitPct: number;
+    readonly nudgeEmergencyThresholdPct: number;
+    readonly autoNudge: boolean;
+}
+/** Input shape (everything optional — omitted keys fall back to defaults). */
+export type AcpSettingsInput = Partial<AcpSettings>;
+/**
+ * Engine defaults for the settings-exposed keys — MUST mirror
+ * `DEFAULT_CONFIG` in src/index.ts (locked together by tests/settings.test.ts,
+ * which compares these against the real DEFAULT_CONFIG field by field).
+ */
+export declare const SETTING_DEFAULTS: {
+    readonly autoModelContextLimit: true;
+    readonly nudgeMaxContextLimitPct: 0.7;
+    readonly nudgeEmergencyThresholdPct: 0.85;
+    readonly autoNudge: true;
+};
+/**
+ * The subset of `AcpConfig` the settings layer may see. Declared structurally
+ * (instead of importing AcpConfig) so this module stays dependency-free —
+ * src/index.ts's `AcpConfig` satisfies it as-is.
+ */
+export interface AcpSettingsCompositionEntry {
+    readonly modelContextLimit?: number;
+    readonly autoModelContextLimit?: boolean;
+    readonly nudgeMinContextLimitPct?: number;
+    readonly nudgeMaxContextLimitPct?: number;
+    readonly nudgeEmergencyThresholdPct?: number;
+    readonly autoNudge?: boolean;
+}
+/**
+ * Filter a composition-row config down to the settings-known scalar keys.
+ * This filtered subset is the ONLY thing handed to the settings layer as its
+ * `base`: the raw row also carries prompts/coreOverrides/countTokens — object
+ * and function values that would flow into the stored resolved snapshot (the
+ * settings resolver does not reject unknown keys) and pollute describe()/clone
+ * paths downstream.
+ */
+export declare function filterSettingsEntry(entry: AcpSettingsCompositionEntry): AcpSettingsInput;
+/** Apply the engine defaults to a (possibly partial) settings input. */
+export declare function resolveAcpSettings(input: AcpSettingsInput): AcpSettings;
+/**
+ * The settings schema. Defaults here are the ENGINE defaults (0.70/0.85),
+ * not the kernel's 0.75/0.95 — an untouched namespace must reproduce exactly
+ * today's behavior. Integer constraint uses `.step(1).min(1)` because
+ * schemastery 3.18.x has no `.int()`/`.positive()` helpers.
+ */
+export declare const AcpSettingsSchema: z<Schemastery.ObjectS<{
+    modelContextLimit: z<number, number>;
+    autoModelContextLimit: z<boolean, boolean>;
+    nudgeMinContextLimitPct: z<number, number>;
+    nudgeMaxContextLimitPct: z<number, number>;
+    nudgeEmergencyThresholdPct: z<number, number>;
+    autoNudge: z<boolean, boolean>;
+}>, Schemastery.ObjectT<{
+    modelContextLimit: z<number, number>;
+    autoModelContextLimit: z<boolean, boolean>;
+    nudgeMinContextLimitPct: z<number, number>;
+    nudgeMaxContextLimitPct: z<number, number>;
+    nudgeEmergencyThresholdPct: z<number, number>;
+    autoNudge: z<boolean, boolean>;
+}>>;
+/** What changed between two settings snapshots, and what the engine must do about it. */
+export interface SettingsChangeEffect {
+    /**
+     * The per-route window cache (which also caches probe FAILURES) must be
+     * dropped so the next step re-resolves windows under the new limits.
+     */
+    clearWindowCache: boolean;
+    /**
+     * Re-enabling nudges clears the per-turn dedup map: entries written while
+     * nudging was off must not suppress the first fresh nudge.
+     */
+    clearNudgeDedup: boolean;
+    /** Human-readable order-anomaly warnings. Accepted, not rejected — a rejected write cannot fix an externally-edited file anyway. */
+    readonly warnings: readonly string[];
+}
+/** Pure diff used by the engine's change handler (unit-testable without a context). */
+export declare function describeSettingsChange(prev: AcpSettings, next: AcpSettings): SettingsChangeEffect;
+/** Result of parsing a `/acp config set` value. `null` means "reset this key". */
+export type ParsedSettingValue = {
+    ok: true;
+    value: number | boolean | null;
+} | {
+    ok: false;
+    reason: string;
+};
+/**
+ * Four-step value parser for `/acp config set` — deliberately NOT bare
+ * JSON.parse, which rejects the most common human inputs (`.7` throws a
+ * SyntaxError and the raw string would then fail schema validation; `null`
+ * would silently mean "unset" only by convention). Order:
+ * 1. `true` / `false` literals → booleans;
+ * 2. anything Number() accepts finitely (`.7`, `2e5`, `200000`) → number;
+ * 3. `null` (word) → reset-this-key sentinel;
+ * 4. otherwise rejected with guidance.
+ */
+export declare function parseSettingValue(raw: string): ParsedSettingValue;
+/** Everything `/acp config` needs from the engine. Fakes in tests implement this directly. */
+export interface SettingsCommandSurface {
+    /** False in processes without a settings provider (plain npm-install compositions): the command degrades to advice instead of failing. */
+    readonly available: boolean;
+    /** Current effective values (works with or without a provider). */
+    snapshot(): AcpSettings;
+    /** Our namespace's descriptor (layers + revision), or undefined while unregistered. */
+    describe(): SettingsDescriptor | undefined;
+    /** Merge a patch into the user section and persist it. */
+    update(patch: AcpSettingsInput): Promise<void>;
+    /** Replace the whole user section ({} resets everything to base/defaults). */
+    replaceSection(section: Record<string, unknown>): Promise<void>;
+}
+/**
+ * Build the command surface over a lazily-captured settings service. The
+ * engine captures the service through a parallel `ctx.inject(['settings'])`,
+ * so the reference may legitimately be undefined for the whole process life
+ * (headless/plain compositions have no settings provider).
+ */
+export declare function makeSettingsCommandSurface(getService: () => SettingsProvider | undefined, getSnapshot: () => AcpSettings): SettingsCommandSurface;

package/dist/state.d.ts

@@ -19,7 +19,18 @@
 import type { Session } from '@deepseek-ai/dsh-session';
 import { type CompressionState } from 'acp-kernel';
 export declare class AcpStateStore {
+    /**
+     * Live kernel states, capped by an LRU policy (issue #113): once the cap is
+     * reached the coldest session's state is dropped, and its next access
+     * rehydrates through stateFor's log-rebuild path below. Rehydration is
+     * deterministic — bN ids are recorded in the durable event or synthesised
+     * in ledger order, and run ids continue after the rehydrated max — so block
+     * identity survives eviction exactly as it survives a restart. Kernel
+     * fields that reset on eviction (tokenSnapshot, nudge cadence, stats
+     * counters) all self-heal on the session's next turn.
+     */
     private readonly states;
+    constructor(limit?: number);
     /** Kernel state for one session, initialised on first access. */
     stateFor(session: Session): CompressionState;
     set(session: Session, state: CompressionState): void;

package/dist/tools.d.ts

@@ -10,15 +10,20 @@
  * @module billion-context-dsh/tools
  */
 import { type ToolDefinition } from '@deepseek-ai/dsh-tools';
-import { type CompressionCore } from 'acp-kernel';
+import { type CompressionCore, type SearchDoc } from 'acp-kernel';
 import type { Agent } from '@deepseek-ai/dsh-agent';
+import type { Session } from '@deepseek-ai/dsh-session';
 import type { AcpStateStore } from './state.ts';
 import { type KernelConfigInput } from './config.ts';
-import type { AcpWindow } from './window.ts';
+import { type AcpWindow } from './window.ts';
 import { type ResolvedPrompts } from './prompts.ts';
+import type { SettingsCommandSurface } from './settings.ts';
+import type { PresetName } from './presets.ts';
 export interface ToolEnvironment extends KernelConfigInput {
     readonly kernel: CompressionCore;
     readonly store: AcpStateStore;
+    /** Display-only: the named preset that produced the nudge thresholds above, if any (`/acp status` names it). Never read by the kernel path. */
+    readonly preset?: PresetName;
     /** Resolve the effective context window for an agent (optional: status falls back to modelContextLimit). */
     readonly windowFor?: (agent: Agent) => Promise<AcpWindow>;
     /** Resolved prompt templates (optional: falls back to DEFAULT_RESOLVED). */
@@ -30,6 +35,12 @@ export interface ToolEnvironment extends KernelConfigInput {
      * (strict providers reject that sequence with HTTP 400).
      */
     readonly compressCallIdsToHide?: Set<string>;
+    /**
+     * Read/write access to the runtime settings layer for `/acp config`.
+     * Absent surfaces (never expected — the engine always builds one) would
+     * degrade the command to advice text.
+     */
+    readonly settingsCommand?: SettingsCommandSurface;
 }
 /**
  * Resolve the effective context window for a tool or command run: probe the
@@ -40,5 +51,105 @@ export interface ToolEnvironment extends KernelConfigInput {
  * for pressure decisions even when auto-detection had found a larger window).
  */
 export declare function resolveEffectiveWindow(env: ToolEnvironment, agent: Agent): Promise<AcpWindow>;
+export declare const compressParameters: {
+    readonly arguments: {
+        readonly type: 'json';
+        readonly description: 'Tolerated wrapped-arguments form (model-generated); unwrapped in handleCompress. Prefer passing content directly.';
+    };
+    readonly topic: {
+        readonly type: 'string';
+        readonly description: 'Fallback topic for entries without their own.';
+    };
+    readonly content: {
+        readonly type: 'array';
+        readonly description: 'One or more ranges to compress, each with startSeq/endSeq boundaries (surface seqs) and a dense summary. Required — pass it directly, not wrapped in an arguments key.';
+        readonly items: {
+            readonly type: 'object';
+            readonly properties: {
+                readonly startSeq: {
+                    readonly required: true;
+                    readonly oneOf: readonly [{
+                        readonly type: 'integer';
+                        readonly description: 'First surface seq of the range.';
+                    }, {
+                        readonly type: 'string';
+                        readonly description: 'Seq as text; a trailing #callId fragment is ignored.';
+                    }];
+                };
+                readonly endSeq: {
+                    readonly required: true;
+                    readonly oneOf: readonly [{
+                        readonly type: 'integer';
+                        readonly description: 'Inclusive last surface seq of the range.';
+                    }, {
+                        readonly type: 'string';
+                        readonly description: 'Seq as text; a trailing #callId fragment is ignored.';
+                    }];
+                };
+                readonly summary: {
+                    readonly type: 'string';
+                    readonly required: true;
+                    readonly description: 'Complete technical summary replacing the range; keep paths, decisions, values verbatim. Minimum 50 characters.';
+                };
+                readonly topic: {
+                    readonly type: 'string';
+                    readonly description: 'Short label (3-5 words) for this range.';
+                };
+                readonly verifiedReadings: {
+                    readonly type: 'array';
+                    readonly items: {
+                        readonly type: 'string';
+                    };
+                    readonly description: 'Optional: acceptance readings that are already green before this compression (e.g. "t0-fastpath 8/8", "closedloop 414/414"). Stored structurally on the compaction/summary event and recovered by verifiedReadingsOf, so later steps need not re-run the checks.';
+                };
+            };
+            readonly additionalProperties: false;
+        };
+    };
+};
+/**
+ * Pure gate helpers for the compress tool's CURRENT-instruction-row rejection.
+ *
+ * Decision history (issue #71 review): the first draft only WARNED when a
+ * manual compress range swallowed a current injected row (F7), because the
+ * compression is safe and self-healing. The owner reversed that during PR1
+ * review: compressing a CURRENT row has NO legitimate outcome — the host
+ * re-injects the newest AGENTS.md copy unconditionally the moment it leaves
+ * the surface (presence gate, deepseek-harness
+ * packages/context/agent-instructions/src/index.ts:137/:163), so the tokens
+ * come straight back and the call is pure waste — and a hard reject keeps the
+ * manual path consistent with the system-side GC's iron rule (PR2: never
+ * clear a group's newest row). STALE copies stay compressible: removing them
+ * while the newest stays visible is the actual cleanup and triggers no
+ * re-injection. The range table (buildCompressibleSeqRanges) never offers
+ * these rows, so the gate only fires on hand-built ranges.
+ *
+ * `guardedRowsInSpan` is the overlap probe. It takes the POSITIONAL span the
+ * transaction will actually shadow (`shadowedSeqsOf`), never a numeric
+ * `start <= seq <= end` interval: the surface is locally non-monotonic after
+ * earlier replacements (a checkpoint seq spliced ahead of older residual
+ * nodes), so a tier-2 distill of two checkpoints can carry a CURRENT
+ * instruction row numerically inside its edges while the sliced span excludes
+ * it — the interval probe rejected exactly the call the nudge hands the model
+ * (issue #71 review B1). Probing the slice also keeps guard and effect in
+ * agreement: `shadowedSeqsOf` is what the transaction prices and
+ * `assertProvenance` verifies.
+ * `protectedRowRejectionNote` renders the rejection the model sees: it names
+ * the offending seqs AND the compressible slices left in the span, so the model
+ * can re-cut (or split into two calls) instead of retrying the same call.
+ * `guardedSurfaceSeqsOf` supplies the protected set.
+ */
+export declare function guardedRowsInSpan(guarded: ReadonlySet<number>, shadowed: readonly number[]): number[];
+export declare function protectedRowRejectionNote(start: number, end: number, hits: readonly number[], shadowed: readonly number[]): string;
+/**
+ * Build the unified SearchDoc[] from the log: one block doc per ledger entry
+ * (ref = compactionId, so `decompress({ blockId })` closes the loop) plus one
+ * message doc per shadowed ORIGINAL (expanded through distilled parents; each
+ * seq is claimed by the earliest/innermost block that covered it, mirroring
+ * pi's owner map — decompress on that block recovers the original).
+ * Cached per log snapshot (see searchDocsCache). Exported for the issue #133
+ * regression tests (not part of the public API — index.ts re-exports only).
+ */
+export declare function buildSearchDocs(session: Session): SearchDoc[];
 /** Build the four ACP model tools bound to one engine. */
 export declare function makeTools(env: ToolEnvironment): ToolDefinition[];

package/dist/window.d.ts

@@ -25,9 +25,11 @@ export interface AcpWindow {
     readonly source: 'explicit' | 'auto' | 'projection' | 'default';
     /**
      * Route the window was resolved for. 'auto' reports the probed route;
-     * 'projection' returns also set it, mirroring agent.options — which can be
-     * stale after a mid-session model switch (inert today: windowSourceLabel
-     * never reads these fields for the projection source).
+     * 'projection' returns also set it, from the session's LIVE route (its last
+     * `request/context` event) — NOT `agent.options`, which is a stale snapshot
+     * after a mid-session model switch; `agent.options` is the fallback only
+     * before the session has recorded any route. (Inert today: windowSourceLabel
+     * never reads these fields for the projection source.)
      */
     readonly provider?: string;
     readonly model?: string;
@@ -66,6 +68,33 @@ export declare function windowSourceLabel(window: AcpWindow): string;
  * Returns null when the host exposes no projection or disclosed no window.
  */
 export declare function projectedContextWindow(agent: Agent): number | null;
+/**
+ * Read the LIVE model route from the session's last `request/context` event.
+ * After a mid-session model switch `agent.options` is a stale snapshot (it
+ * names the PREVIOUS route), so the per-route output cap must be resolved
+ * against this live route instead — otherwise the cap lags one switch behind
+ * (a 32K cap from a just-left model subtracted from the new model's window).
+ * Returns null before the session has recorded any route, so callers fall
+ * back to `agent.options`. Never throws, like `probeModelWindow`: the caller
+ * runs inside `agent/pre-step`, which has no surrounding try.
+ */
+export declare function liveRoute(agent: Agent): {
+    provider: string;
+    model: string;
+} | null;
+/**
+ * The route the per-route output cap and the compression provenance must be
+ * resolved against, in ONE place: the session's live `request/context` route,
+ * falling back to `agent.options` only before the session has recorded any
+ * route. `windowFor` (src/index.ts), the `compress` tool (src/tools.ts) and
+ * `/acp compress` (src/commands.ts) all need this exact pair; three hand-copied
+ * copies is precisely how a stale-route bug gets fixed in one call site and
+ * left behind in the others.
+ */
+export declare function routeFor(agent: Agent): {
+    provider: string;
+    model: string;
+};
 /** The model window plus the adapter's per-request output cap, in one probe. */
 export interface ModelWindowProbe {
     /** The model's total context window in tokens, when disclosed. */

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "billion-context-dsh",
-	"version": "0.2.21",
+	"version": "0.2.22",
 	"description": "Active Context Pruning (ACP) for the DeepSeek Harness — model-driven context management as a CompactionEngine backend.",
 	"keywords": [
 		"deepseek",
@@ -43,27 +43,35 @@
 	"scripts": {
 		"typecheck": "tsc --noEmit",
 		"build": "tsup && tsc --emitDeclarationOnly",
-		"test": "node --import tsx --test tests/*.test.ts tests/kernel-upstream/*.test.ts"
+		"test": "node --import tsx --test tests/*.test.ts tests/kernel-upstream/*.test.ts",
+		"test:e2e": "node scripts/e2e/run-e2e.mjs"
 	},
 	"peerDependencies": {
 		"@deepseek-ai/cordis": "^4.0.1",
-		"@deepseek-ai/dsh-compaction": "^0.1.0-rc.6 || ^0.1.1-rc.1 || ^0.1.2-alpha.4",
-		"@deepseek-ai/dsh-session": "^0.1.0-rc.6 || ^0.1.1-rc.1 || ^0.1.2-alpha.4",
-		"@deepseek-ai/dsh-llm": "^0.1.0-rc.6 || ^0.1.1-rc.1 || ^0.1.2-alpha.4",
-		"@deepseek-ai/dsh-tools": "^0.1.0-rc.6 || ^0.1.1-rc.1 || ^0.1.2-alpha.4"
+		"@deepseek-ai/dsh-compaction": ">=0.1.5-alpha.1 <0.1.6-0",
+		"@deepseek-ai/dsh-session": ">=0.1.5-alpha.1 <0.1.6-0",
+		"@deepseek-ai/dsh-llm": ">=0.1.5-alpha.1 <0.1.6-0",
+		"@deepseek-ai/dsh-tools": ">=0.1.5-alpha.1 <0.1.6-0",
+		"@deepseek-ai/dsh-settings": ">=0.1.5-alpha.1 <0.1.6-0",
+		"@deepseek-ai/schemastery": "^3.18.2"
 	},
 	"devDependencies": {
-		"acp-kernel": "0.0.29",
-		"@deepseek-ai/cordis": "4.0.1",
-		"@deepseek-ai/dsh-agent": "0.1.0-rc.6",
-		"@deepseek-ai/dsh-commands": "0.1.0-rc.6",
-		"@deepseek-ai/dsh-compaction": "0.1.0-rc.6",
-		"@deepseek-ai/dsh-llm": "0.1.0-rc.6",
-		"@deepseek-ai/dsh-session": "0.1.0-rc.6",
-		"@deepseek-ai/dsh-session-projection": "0.1.0-rc.6",
-		"@deepseek-ai/dsh-token-meter": "^0.1.0-rc.6",
-		"@deepseek-ai/dsh-tools": "0.1.0-rc.6",
-		"@deepseek-ai/schemastery": "3.18.1",
+		"acp-kernel": "0.0.63",
+		"@deepseek-ai/cordis": "4.0.2",
+		"@deepseek-ai/dsh-agent": "0.1.5-rc.2",
+		"@deepseek-ai/dsh-agent-loop": "0.1.5-rc.2",
+		"@deepseek-ai/dsh-agent-loop-testkit": "0.1.5-rc.2",
+		"@deepseek-ai/dsh-commands": "0.1.5-rc.2",
+		"@deepseek-ai/dsh-compaction": "0.1.5-rc.2",
+		"@deepseek-ai/dsh-llm": "0.1.5-rc.2",
+		"@deepseek-ai/dsh-llm-deepseek": "0.1.5-rc.2",
+		"@deepseek-ai/dsh-session": "0.1.5-rc.2",
+		"@deepseek-ai/dsh-session-format-v0-to-v1": "0.1.5-rc.2",
+		"@deepseek-ai/dsh-session-projection": "0.1.5-rc.2",
+		"@deepseek-ai/dsh-settings": "0.1.5-rc.2",
+		"@deepseek-ai/dsh-token-meter": "0.1.5-rc.2",
+		"@deepseek-ai/dsh-tools": "0.1.5-rc.2",
+		"@deepseek-ai/schemastery": "3.18.2",
 		"@types/node": "^26.1.2",
 		"semver": "^7.7.1",
 		"tsup": "^8.5.1",

package/dist/tool-pairing.d.ts

@@ -1,36 +0,0 @@
-/**
- * Local tool-pairing balance checks over the session surface.
- *
- * UPSTREAM: `@deepseek-ai/dsh-compaction@0.1.2-rc.1` reads the REMOVED
- * `session.events` API in its balance cache — `extendCache` does
- * `const events = session.events` and `eventForSeq` does `events[seq]`, so on
- * every dsh 0.1.2 host the official `toolPairingBalancedBefore/After` helpers
- * throw `TypeError: Cannot read properties of undefined (reading '<seq>')`.
- * The host's API docs require compaction backends to use these helpers for
- * edge checks, and the host's own `dsh-compaction-basic` calls them too, so
- * ALL compaction on a 0.1.2-rc.1 host crashes (reproduced offline and pinned
- * in issue #124; tracked in docs/dsh-porting-verification.md).
- *
- * This module mirrors the host's algorithm line for line (per-session cache
- * keyed by `surface.replaceGeneration`, the `cutBalanced` fold, identical
- * error messages) with ONE deliberate difference: events are read through the
- * cross-version accessor `eventAtOf` (src/session-events.ts), which works on
- * both the 0.1.0/0.1.1 lines (`events[seq]`) and 0.1.2+ (`eventAt(seq)`).
- * DELETE this module and switch `src/region.ts` back to
- * `@deepseek-ai/dsh-compaction`'s helpers the moment the host fix ships.
- */
-import type { Session } from '@deepseek-ai/dsh-session';
-/**
- * Whether the cut immediately before a current surface sequence is tool-pairing balanced.
- * @param session - session whose surface is checked.
- * @param seq - event sequence whose leading cut is checked.
- * @returns true when no unanswered tool call crosses the cut.
- */
-export declare function toolPairingBalancedBefore(session: Session, seq: number): boolean;
-/**
- * Whether the cut immediately after a current surface sequence is tool-pairing balanced.
- * @param session - session whose surface is checked.
- * @param seq - event sequence whose trailing cut is checked.
- * @returns true when no unanswered tool call crosses the cut.
- */
-export declare function toolPairingBalancedAfter(session: Session, seq: number): boolean;