billion-context-dsh 0.2.1 → 0.2.2

package/dist/region.d.ts

@@ -143,6 +143,50 @@ export interface SeqCompressibleRange {
     readonly count: number;
     readonly tokens: number;
 }
+/**
+ * Hide one successful `compress` tool's call/result pair after its tool/result
+ * has been logged. The durable compaction summary is inserted BEFORE the
+ * current tool result (the compress tool runs mid-turn), so leaving the pair on
+ * the surface would produce `assistant(tool_calls) → user(summary) →
+ * tool(result)` — rejected by strict providers. Replacing both nodes with a
+ * plain user message (the result text) removes the pair from the derived
+ * surface without touching the compaction block.
+ */
+export declare function hideCompressToolPair(session: Session, callId: string, resultSeq?: number): boolean;
+/**
+ * Surface-level orphan cleanup: hide tool/result nodes with no matching call,
+ * assistant tool-call nodes whose calls all lack results, and "broken pairs"
+ * whose result is NOT adjacent to the call node on the surface (a
+ * non-tool/result node — typically the compaction summary a buggy older
+ * version inserted between a compress call and its result — sits between
+ * them). A single orphan result corrupts the whole tool-pairing balance cache
+ * (every range resolve throws), orphan calls fragment large ranges into tiny
+ * uncompressed fragments, and a broken pair cannot serialize for strict
+ * providers — the mechanisms behind issue #18's "only ~28 tokens visible".
+ * Uses the same durable prune protocol as `hideSurfaceSeqs`, so the removed
+ * nodes stay recoverable from the append-only log.
+ */
+export declare function stripOrphanedSurfaceToolMessages(session: Session, inFlightCallIds?: ReadonlySet<string>): number;
+/**
+ * All tool-call ids currently visible on the surface with no matching
+ * tool/result yet — the in-flight calls of the current step. Sibling tools
+ * called in the same assistant message as `compress` are in-flight too, so
+ * `handleCompress` must protect the whole set (not just its own call id) or
+ * the sibling call would be pruned as an orphan and its result would land
+ * orphaned (HTTP 400 until the next cleanup).
+ */
+export declare function openToolCallIds(session: Session): Set<string>;
+/**
+ * Schedule `hideCompressToolPair` on the microtask queue. `session.append`
+ * is NOT reentrant: running it synchronously inside a `session/event`
+ * listener (while the outer append is still publishing) throws "session
+ * append cannot reenter while another append is being published" on live,
+ * store-attached sessions, and the dispatcher silently swallows the error —
+ * so a synchronous hide is a silent no-op in production. A microtask drains
+ * after the current append fully publishes and before the agent loop resumes,
+ * so the pair is hidden before the next request is built.
+ */
+export declare function deferCompressPairHide(session: Session, callId: string, resultSeq: number, onError?: (error: unknown) => void): void;
 /**
  * Compute compressible spans directly from the surface — independent of the
  * kernel's ref map, which can drift after surface replacements in long

package/dist/tools.d.ts

@@ -23,6 +23,13 @@ export interface ToolEnvironment extends KernelConfigInput {
     readonly windowFor?: (agent: Agent) => Promise<AcpWindow>;
     /** Resolved prompt templates (optional: falls back to DEFAULT_RESOLVED). */
     readonly prompts?: ResolvedPrompts;
+    /**
+     * Call ids of compress invocations that created a durable block. The engine
+     * listens for the matching `tool/result` and hides the call/result pair from
+     * the surface, preventing the compaction summary from sitting between them
+     * (strict providers reject that sequence with HTTP 400).
+     */
+    readonly compressCallIdsToHide?: Set<string>;
 }
 /** Build the four ACP model tools bound to one engine. */
 export declare function makeTools(env: ToolEnvironment): ToolDefinition[];

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "billion-context-dsh",
-	"version": "0.2.1",
+	"version": "0.2.2",
 	"description": "Active Context Pruning (ACP) for the DeepSeek Harness — model-driven context management as a CompactionEngine backend.",
 	"keywords": [
 		"deepseek",