billion-context-omp 0.3.1 → 0.3.2-pr.138.3

package/dist/messages.d.ts

@@ -8,36 +8,11 @@ export declare function streamToCoreMessages(stream: AgentMessage[]): CoreMessag
  *  skip replaying compress calls that were REJECTED live ("No changes
  *  applied") — only calls that actually created blocks should rebuild them. */
 export declare function toolResultTexts(stream: AgentMessage[]): Map<string, string>;
-export interface StreamCompressCall {
-    id: string;
-    ranges: {
-        startRef: string;
-        endRef: string;
-        summary: string;
-        topic?: string;
-        summaryMaxChars?: number;
-        compressCallId: string;
-    }[];
-}
+export type { StreamCompressCall } from "acp-kernel/wire";
+import type { StreamCompressCall } from "acp-kernel/wire";
 export declare function findCompressCalls(message: AgentMessage): StreamCompressCall[];
-/** Extract a compress tool's arguments from a stream toolCall. Two call
- *  shapes exist: (1) top-level — our tools are registered with
- *  loadMode:"essential" so omp's tools.xdev does NOT mount them as xd://
- *  devices; the stream shows name:"compress" directly. (2) legacy xd:// —
- *  sessions recorded before that change (or hosts with tools.xdev forcing
- *  discoverable mounting) invoked compress through the write tool with path
- *  "xd://compress" and the tool args JSON-encoded in the content field. Both
- *  shapes must replay from the stream. Returns normalized compress args
- *  (content array
- *  plus optional topic / summaryMaxChars from wherever they live). */
-export declare function compressToolArgs(call: {
-    name: string;
-    arguments?: unknown;
-}): {
-    content: unknown[];
-    topic?: unknown;
-    summaryMaxChars?: unknown;
-} | null;
+import { compressToolArgs } from "acp-kernel/wire";
+export { compressToolArgs };
 export declare function extractText(content: unknown, stripTags?: boolean): string;
 export declare function stripRefTag(text: string): string;
 export declare function messageIdentity(message: unknown): string;

package/dist/runtime.d.ts

@@ -2,13 +2,6 @@ import type { ExtensionContext } from "@oh-my-pi/pi-coding-agent";
 import { type CompressionCore, type CompressionState, type Config, type CoreMessage, type Prompts } from "acp-kernel";
 import { type AdapterConfig } from "./config.js";
 import type { BiliMessage } from "acp-kernel/wire";
-import { type AgentMessage } from "./messages.js";
-export interface FoldResult {
-    state: CompressionState;
-    coreMessages: CoreMessage[];
-    originalById: Map<string, AgentMessage>;
-    streamLen: number;
-}
 /** Core-space fold result (provider mode): no originalById — the output
  *  rebuilds straight onto the wire via the kernel codecs. */
 export interface CoreFoldResult {
@@ -24,22 +17,17 @@ export interface AcpRuntime {
     setPrompts(prompts: Prompts): void;
     liveContextLimit(ctx: ExtensionContext): number;
     configFor(ctx: ExtensionContext): Config;
-    foldStream(ctx: ExtensionContext, stream: AgentMessage[]): FoldResult;
     /** Core-space fold (provider mode): the wire payload already parsed to
-   *  BiliMessage[] by the kernel codec; same incremental LCP + replay
-   *  semantics as foldStream, content-hash id space (wire-fold.ts). */
+   *  BiliMessage[] by the kernel codec; incremental LCP + replay semantics,
+   *  content-hash id space (wire-fold.ts). */
     foldStreamCore(ctx: ExtensionContext, stream: BiliMessage[]): CoreFoldResult;
     stateFor(ctx: ExtensionContext): Promise<{
         state: CompressionState;
         coreMessages: CoreMessage[];
     }>;
-    /** Commit the folded state to the slot space the session's CURRENT mode
-     *  folds in (provider -> core slot, context -> context slot) — the mirror
-     *  of stateFor: a commit must land where the next read goes (issue #90). */
+    /** Commit the folded state to the core slot — the mirror of stateFor: a
+     *  commit must land where the next read goes (issue #90). */
     commitFoldState(ctx: ExtensionContext, state: CompressionState, toolCallId?: string): void;
-    /** Record the identity sequence of the last rebuilt output so the next
-     *  foldStream can recognize omp re-feeding it (issue #52). */
-    recordRebuiltOutput(ctx: ExtensionContext, rebuilt: AgentMessage[]): void;
     /** Track the per-session streak of consecutively REJECTED compress calls.
      *  `ok=false` increments and returns the new streak; `ok=true` resets to 0.
      *  A re-fold (rewritten stream prefix) drops the slot and starts at 0. */
@@ -48,6 +36,22 @@ export interface AcpRuntime {
      *  mode folds in (issue #104: the nudge must not demand compression while
      *  compress calls are being rejected in a row). */
     rejectStreakFor(ctx: ExtensionContext): number;
+    /** Restore the fold slot from the previous process's checkpoint (issue
+     *  #130). Returns true when the session already has a live in-memory slot
+     *  (in-process switch back — never clobbered) or a valid checkpoint was
+     *  loaded. Callers skip the primeFold mirror: a mirror that guesses the
+     *  host's view→wire projection lands in a different fingerprint space,
+     *  which is exactly the bug the checkpoint exists to fix. */
+    restoreFold(ctx: ExtensionContext): boolean;
+    /** Debounced checkpoint of the live fold slot. Called from the live fold
+     *  path only (wire fold, turn commit, compress commit) — preview/mirror
+     *  slots are never persisted. No-op when persistence is disabled. */
+    scheduleFoldSnapshot(ctx: ExtensionContext): void;
+    /** Synchronously flush the session's checkpoint. For session_shutdown:
+     *  the host may exit as soon as the handler returns, so a debounced save
+     *  would be dropped with the process. Returns false when the write
+     *  failed (the in-memory slot is unaffected either way). */
+    flushFoldSync(sid: string): boolean;
     forgetSession(sid: string): void;
     /** Rebuild blocks from the persisted session at session_start so /acp and
      *  acp_status show them BEFORE the first LLM call of a resumed session.

package/dist/transform-mode.d.ts

@@ -1,20 +1,17 @@
-import type { AdapterConfig } from "./config.js";
+export declare const MIN_HOST_VERSION: readonly [number, number, number];
 export declare function hostVersionAtLeast(min: readonly [number, number, number], version?: string): boolean;
-export declare function resolveTransformMode(adapter: Pick<AdapterConfig, "transformMode">, model: {
-    api?: string;
-} | undefined, hostVersion?: string): "context" | "provider";
+/** True when the running host meets the minimum version omp requires. */
+export declare function hostMeetsMinimum(version?: string): boolean;
 export interface ProviderDeliveryWarning {
     key: string;
     reason: string;
     message: string;
 }
-/** An explicit transformMode "provider" is an escape hatch for patched hosts
- *  — but on stock hosts some APIs silently deliver NOTHING: before 17.3.8 the
- *  host drops the before_provider_request replacement on openai-completions /
- *  bedrock / cursor (upstream can1357/oh-my-pi#8717, issue #83), and bedrock /
- *  cursor bodies still have no codec path even on newer hosts. The unset
- *  default already avoids all of this; only an explicit override can land
- *  here, so surface why instead of failing silently (ework issue #3). */
-export declare function providerDeliveryWarning(adapter: Pick<AdapterConfig, "transformMode">, model: {
+/** Compression is delivered only where the kernel has a codec for the wire
+ *  body. On stock hosts the other APIs (bedrock / cursor / google / devin /
+ *  unknown) have no codec path yet — the payload passes through untransformed
+ *  and compression is silently a no-op. Surface why instead of failing
+ *  silently (issue #83; kernel codecs tracked upstream). */
+export declare function providerDeliveryWarning(model: {
     api?: string;
-} | undefined, hostVersion?: string): ProviderDeliveryWarning | undefined;
+} | undefined): ProviderDeliveryWarning | undefined;

package/dist/user-config.d.ts

@@ -6,7 +6,6 @@ import type { AdapterConfig, CompressConfig, DelegateConfig } from "./config.js"
 export interface UserAcpConfig {
     debug?: boolean;
     autoUpdate?: boolean;
-    transformMode?: "context" | "provider";
     modelContextLimit?: number;
     toolBashDefaultTimeout?: number;
     toolOutputMaxBytes?: number;

package/dist/wire-fold.d.ts

@@ -1,14 +1,27 @@
-import { type BiliMessage } from "acp-kernel/wire";
-import { type CompressionState, type Config, type CoreMessage } from "acp-kernel";
-import type { AgentMessage, BlockLike, StreamCompressCall } from "./messages.js";
-export type ProviderWireFormat = "anthropic" | "openai";
+import { type BiliMessage, type MirrorMessage, type ResponsesProjection } from "acp-kernel/wire";
+import { type CompressionState, type Config } from "acp-kernel";
+import type { AgentMessage } from "./messages.js";
+export type ProviderWireFormat = "anthropic" | "openai" | "responses";
 /** Kernel format detection narrowed to the formats the omp pipeline can
- *  rebuild onto the wire. null = fail-open (pass the payload through). */
+ *  rebuild onto the wire. null = fail-open (pass the payload through).
+ *  The kernel's detectWireFormat only recognizes `input` arrays as
+ *  "responses"; string inputs (a single user message) are also responses
+ *  bodies (the kernel's responsesToCore handles them), so we add that case. */
 export declare function detectProviderWireFormat(payload: unknown): ProviderWireFormat | null;
 export declare function payloadToCore(payload: unknown, fmt: ProviderWireFormat): {
     msgs: BiliMessage[];
     cacheControls?: Map<string, unknown>;
+    systemText?: string;
 };
+/** Parse a responses body into the kernel's projection (layout + core pieces).
+ *  The projection is needed for the rebuild (patchResponsesInput) — it carries
+ *  the original item layout so the round-trip preserves opaque items and
+ *  patches text in place rather than rebuilding from scratch. */
+export declare function responsesProjection(payload: unknown): ResponsesProjection;
+/** Rebuild the responses `input` from the projection + transformed core
+ *  messages. Returns a string when the original input was a string (and the
+ *  transform kept it a single user text piece); otherwise an item array. */
+export declare function responsesRebuild(projection: ResponsesProjection, msgs: BiliMessage[]): string | unknown[];
 export declare function coreToPayloadMessages(msgs: BiliMessage[], fmt: ProviderWireFormat, cacheControls?: Map<string, unknown>): unknown[];
 export type Representability = {
     ok: true;
@@ -29,6 +42,16 @@ export declare function payloadRepresentable(payload: unknown, fmt: ProviderWire
  *  the details and flips "" back to null; this pass re-attaches both so the
  *  post-surgery body keeps the host's wire contract. */
 export declare function restoreOpenaiWireFidelity(originalMessages: unknown[], rebuilt: unknown[]): unknown[];
+/** Re-attach the leading system/developer messages the kernel hoisted out of
+ *  the fold id space (acp-kernel 0.0.37). The rebuilt message list no longer
+ *  carries them; without this pass, a compression covering the old system
+ *  piece dropped the model's system prompt from the wire entirely (observed
+ *  on glm-5.3: post-compression requests went from systemLen 45151 to 0).
+ *  Original messages are re-attached verbatim so the host's wire shape —
+ *  system vs developer roles, message count, name fields — survives
+ *  byte-for-byte. Mirrors the anthropic path, where the top-level system
+ *  field never enters the fold at all. */
+export declare function restoreOpenaiSystemPrefix(originalMessages: unknown[], rebuilt: unknown[]): unknown[];
 export type WireTagRenderScope = {
     config: Config;
     tokenCount: number;
@@ -55,93 +78,23 @@ export declare function applyWireTagContract(msgs: BiliMessage[], state: Compres
  *  them and they ride back in the next request) — stripped before hashing
  *  so re-folds of an unmutated prefix stay incremental. */
 export declare function coreIdentity(msg: BiliMessage): string;
-/** toolCallId → toolName from the stream's tool-call pieces. The kernel
- *  codecs do not carry tool names on tool-result pieces, so protection
- *  checks (compress results stay ref-BLOCKED) resolve the name here. */
-export declare function toolCallNames(msgs: BiliMessage[]): Map<string, string>;
-export declare function toolResultTextsCore(msgs: BiliMessage[]): Map<string, string>;
-/** Compress calls carried by a core tool-call piece. Same two shapes as the
- *  AgentMessage stream (direct compress; legacy xd://compress via write),
- *  with the arguments JSON-encoded in the piece's text. */
-export declare function findCompressCallsCore(msg: BiliMessage): StreamCompressCall[];
-/** Span fingerprint in content-hash space: hash the content keys of the
- *  exact first/last covered pieces. Boundary ids are pre-resolved (byRef /
- *  block lookup) — unlike the pN-space spanFingerprint there is no
- *  position parsing, ids are unique per piece. */
-export declare function spanFingerprintCore(coreMessages: CoreMessage[], startId: string, endId: string): string;
-/** Index-based span fingerprint (issue #91 replay fallback): hash the content
- *  keys of the pieces AT the given stream positions. The stored fp still
- *  decides keep/drop — the position is only a recovery hint for a drifted
- *  boundary whose content-hash id no longer matches, so a benign tail drift
- *  (first-4096 intact) is kept while a real rewrite mismatches. */
-export declare function spanFingerprintCoreIdx(coreMessages: CoreMessage[], startIdx: number, endIdx: number): string;
-/** Resolve a range boundary to the exact id of the piece it names, in
- *  content-hash space. Message refs go through byRef; block refs resolve to
- *  the earliest (min) or latest (max) covered piece by STREAM ORDER
- *  (index in coreMessages — the hash ids carry no position). */
-export declare function boundaryRawCore(ref: string, byRef: Record<string, string>, blocks: BlockLike[], coreMessages: CoreMessage[], pick: "min" | "max"): string;
-/** Resolve a range boundary to its STREAM INDEX in content-hash space. byRef /
- *  block lookup first (the exact piece it names, by array order); on a missed
- *  id (a drift re-hashed the piece so its carried ref dangles) fall back to
- *  the compress-time recorded index — the position hint, issue #91. -1 =
- *  unresolvable. */
-export declare function boundaryIndexCore(ref: string, byRef: Record<string, string>, blocks: BlockLike[], coreMessages: CoreMessage[], pick: "min" | "max", fallbackIdx?: number): number;
-/** Structured replay-guard verdict (issue #91, rework): the position
- *  fallback recovers the STREAM INDEX of a drifted boundary, but the kernel
- *  resolves ranges by REF — so when a recorded m-ref dangles, the replay
- *  must re-apply that boundary under the CURRENT ref of the recovered piece.
- *  `remap` carries exactly that (only dangling m-refs are remapped; block
- *  refs resolve themselves inside the kernel and are never touched). */
-export type ReplayRangeVerdict = {
-    /** Stale: the range must be dropped (master semantics, unchanged). */
-    reject?: string;
-    /** Dangling m-refs recovered by position, remapped to current refs. */
-    remap?: {
-        startRef?: string;
-        endRef?: string;
-    };
-    /** True when the result text carried a [pos=] pair for this range —
-     *  with `reject` set it marks a RECOVERY FAILURE (always logged). */
-    hint?: boolean;
-    /** Diagnostics — always logged when a recovery happens. */
-    recovered?: {
-        pos: string;
-        startIdx: number;
-        endIdx: number;
-    };
-};
-/** Current m-ref of the piece at stream index idx (inverse byRef scan).
- *  "" when the piece has no ref (protected) — the replay must fail closed
- *  rather than hand the kernel a ref it does not know. Replay-time only
- *  (replayed compress calls), so the O(refs) scan stays off the hot path. */
-export declare function refOfPieceCore(coreMessages: BiliMessage[], idx: number, byRef: Record<string, string>): string;
-export declare function staleRangeCore(r: {
-    startRef: string;
-    endRef: string;
-}, rangeIndex: number, resultText: string, coreMessages: BiliMessage[], callIndex: number, byRef: Record<string, string>, blocks: BlockLike[]): ReplayRangeVerdict;
-/** One fingerprint per range for the replay guard, content-hash space
- *  (mirrors rangeFingerprints for the pN space). */
-export declare function rangeFingerprintsCore(ranges: Array<{
-    startRef: string;
-    endRef: string;
-}>, coreMessages: BiliMessage[], byRef: Record<string, string>, blocks: BlockLike[]): string[];
-/** One boundary-index pair per range for the replay fallback (issue #91),
- *  aligned with rangeFingerprintsCore: the stream index of each range's exact
- *  first/last covered piece at record time ("-1" pair when a boundary can't
- *  be positioned), so the replay can recover a drifted boundary by position. */
-export declare function rangePositionsCore(ranges: Array<{
-    startRef: string;
-    endRef: string;
-}>, coreMessages: CoreMessage[], byRef: Record<string, string>, blocks: BlockLike[]): string[];
-/** Rebuild the WIRE-SHAPE projection of the persisted session (the mirror
- *  of the host's convertToLlm for openai chat) and parse it with the kernel
- *  codec, so primeFold (provider mode) folds exactly the space the live
- *  provider requests fold: system prompt first (it takes m00001), one
- *  tool-result piece per tool result, thinking dropped (issue #64). */
+export { toolCallNames, toolResultTextsCore, findCompressCallsCore, spanFingerprintCore, spanFingerprintCoreIdx, boundaryRawCore, boundaryIndexCore, refOfPieceCore, staleRangeCore, rangeFingerprintsCore, rangePositionsCore, } from "acp-kernel/wire";
+export type { ReplayRangeVerdict } from "acp-kernel/wire";
+/** Map the persisted session view onto the kernel's neutral MirrorMessage:
+ *  the only omp-side shape knowledge left in this module — ref-tag
+ *  stripping (a persisted-format concern, messages.ts) and the pi block
+ *  types. Every wire-shape rule (system placement, reasoning_content vs
+ *  thinking blocks vs summary_text, tool_result folding, whitespace
+ *  handling) lives single-sourced in the acp-kernel mirror constructors
+ *  (≥0.0.35, PR #114). */
+export declare function toMirrorView(view: AgentMessage[]): MirrorMessage[];
+/** primeFold openai/completions mirror (issue #64): system first, thinking
+ *  as the `reasoning_content` field (issue #103); inline `<think>` hosts
+ *  land in the same identity space via kernel normalization (PR #112). */
 export declare function viewToCoreStream(view: AgentMessage[], systemText: string): BiliMessage[];
-/** Anthropic-flavoured wire mirror for primeFold: the live anthropic
- *  request carries the system prompt as the TOP-LEVEL `system` field (out
- *  of the fold space) and folds tool results into user messages — mirror
- *  exactly that, or the preview lands in a different ref space than the
- *  live request (issue #64). */
+/** primeFold anthropic/messages mirror (issue #64): system out of the fold
+ *  space, tool results folded into user messages, signed thinking blocks. */
 export declare function viewToAnthropicCore(view: AgentMessage[]): BiliMessage[];
+/** primeFold responses mirror (issue #64, responses variant): system in the
+ *  top-level `instructions` field, conversation as the `input` item array. */
+export declare function viewToResponsesCore(view: AgentMessage[], systemText: string): BiliMessage[];

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "billion-context-omp",
-	"version": "0.3.1",
+	"version": "0.3.2-pr.138.3",
 	"description": "One billion, not one million. Model-driven context management for the oh-my-pi (omp) coding agent.",
 	"main": "dist/index.js",
 	"types": "dist/index.d.ts",
@@ -68,8 +68,7 @@
 		"@oh-my-pi/pi-coding-agent": "17.3.8",
 		"@oh-my-pi/pi-utils": "17.3.8",
 		"@types/node": "^26.1.2",
-		"acp-kernel": "0.0.32",
-		"billion-context-kit": "0.2.0",
+		"acp-kernel": "^0.0.42",
 		"bun-types": "^1.3.14",
 		"tsup": "^8.5.1",
 		"tsx": "^4.23.1",