billion-context-pi-lean 0.2.0 → 0.2.1

package/dist/messages.d.ts

@@ -26,11 +26,7 @@ export interface AcpNudgeRecord {
  *  acp-rule reports)
  *  (Pi-native projection semantics, session-manager.d.ts). The non-empty gate
  *  uses the exact same extractText check as the projection below, so an entry
- *  either enters context or it doesn't — and only entries that enter context
- *  can delimit a turn (#364 acceptance c: empty control signals start none).
- *  Shared by the turn-boundary predicate in src/turn-boundary.ts so the two
- *  views can never drift apart; defined here (not there) because it needs
- *  extractText — importing that back would create a cycle. */
+ *  either enters context or it doesn't. */
 export declare function isCustomMessageEntry(entry: TurnBoundaryEntry): entry is TurnBoundaryEntry & {
     type: "custom_message";
 };
@@ -64,10 +60,7 @@ export declare class EntryProjectionCache {
 export declare function extractText(content: unknown): string;
 export declare function thinkingTokenCount(content: unknown): number;
 export declare function countImageBlocks(content: unknown): number;
-export declare function messageIdentity(message: unknown): string;
-export declare function messageRef(message: unknown): string | undefined;
 export declare const TRUNCATION_MARKER = "[truncated for context space]";
-export declare function matchesStoredText(stored: string, visible: string): boolean;
 export declare function coreOutToAgentMessages(coreOut: CoreMessage[], originalById: Map<string, AgentMessage>): AgentMessage[];
 export interface LatestUserGuardResult {
     messages: CoreMessage[];

package/dist/reasoning-drop.d.ts

@@ -1,7 +1,7 @@
 import type { SessionMessageEntry } from "@earendil-works/pi-coding-agent";
 type AgentMessage = SessionMessageEntry["message"];
 /** [#336] Config for dropping oversized reasoning (thinking) parts from
- *  historical `compress` tool calls — exact alignment with opencode-acp #377.
+ *  historical `compress` tool calls.
  *  `compress` calls are hard-exempt from compression (their tool results are
  *  the anchors that keep block summaries addressable), so their thinking
  *  rides along every request as an unreclaimable context floor. This pass
@@ -42,7 +42,7 @@ export declare function isStrictReasoningEcho(provider?: string, baseUrl?: strin
  *  no `thinking` parts, so the pass would be a no-op regardless. */
 export declare function applyStrictReasoningGate(cfg: Required<CompressReasoningConfig>, provider?: string, baseUrl?: string): Required<CompressReasoningConfig>;
 export declare function countThinkingChars(messages: AgentMessage[]): number;
-/** Request-time pass aligned with opencode-acp #377: remove `thinking` parts
+/** Request-time pass: remove `thinking` parts
  *  from a message only when ALL gates hold —
  *  1. closed round [#348]: EVERY `compress` toolCall in the message has its
  *     tool-result message (role `toolResult`, matching `toolCallId`) at a

package/dist/runtime.d.ts

@@ -7,35 +7,17 @@ import { entriesToCoreMessages } from "./messages.js";
 import { SessionStateStore } from "./state.js";
 import { ThrottleEpisode } from "./throttle-retry.js";
 import { OverflowEpisode } from "./overflow-selfheal.js";
-import { type TurnBoundaryPolicy } from "./turn-boundary.js";
 type AgentMessage = SessionMessageEntry["message"];
-export declare function readContextEntries(sm: ExtensionContext["sessionManager"]): SessionEntry[];
-export declare function isPiHost(sm: ExtensionContext["sessionManager"]): boolean;
-/** #453: key for the compress-retry circuit breaker, derived from PERSISTED
- *  entries only. Live-merged tail ids (content-addressed since #459) can still
- *  churn when the host's view of a not-yet-persisted message drifts, so a
- *  breaker keyed on the merged view could reset failCount mid-episode (#452
- *  log: cap → inject loop). Persisted entry ids are immutable; this key
- *  changes only when a genuine new user message reaches the session log.
- *  pi-native hosts see no change. */
-export declare function retryBreakerKey(sm: ExtensionContext["sessionManager"], policy?: TurnBoundaryPolicy): string | undefined;
-/** Minimal identity of a session for state operations that don't need a live
- *  ExtensionContext (hosts deriving inline child sessions build these from
- *  whatever session handles they hold). */
-export interface SessionRef {
-    sessionId: string;
-    sessionFile?: string;
-}
 export interface AcpRuntime {
     core: CompressionCore;
-    /** Set when the host is unsupported (currently: OMP / oh-my-pi) or when the
-     *  model's baseUrl routes through the billion-context wire proxy (#296).
+    /** Set when the model's traffic routes through the billion-context wire
+     *  proxy (#296), which then owns compression.
      *  Once true, the extension stands down: the context transform, system-prompt
      *  injection, compaction-cancel and ACP tools all no-op so the host runs
      *  untouched. Set at session_start (first context event as fallback). */
     refused: boolean;
-    /** User-facing reason shown when a refused ACP tool is invoked; null means
-     *  the default OMP refusal text applies. Set together with `refused`. */
+    /** User-facing reason shown when a refused ACP tool is invoked. Set
+     *  together with `refused`. */
     refusalMessage: string | null;
     /** Per-session provider-throttle retry episode (attempt budget + kick
      *  pacing), keyed by session id so concurrent sessions in one extension
@@ -71,9 +53,7 @@ export interface AcpRuntime {
     nudgeRecordedFor(sid: string, turnKey: string): boolean;
     /** Process compress toolResults for the CURRENT user turn only (the caller
      *  scopes the list — see collectCompressOutcomes in src/index.ts); idempotent
-     *  per toolCallId. turnKey MUST be the stable persisted-boundary key
-     *  (retryBreakerKey) — a key derived from live-merged entries churns under
-     *  fork hosts and resets the counter mid-episode (#453). Outcome classes:
+     *  per toolCallId. turnKey is the last user-turn boundary. Outcome classes:
      *  isError or noop (0-block panel) → failure (count++), success panel
      *  (>= 1 block) → reset, other non-error text → neutral (count unchanged).
      *  Returns the failure count and whether the cap was just reached. */
@@ -108,7 +88,7 @@ export interface AcpRuntime {
      *  config when the contents change. Cheap no-op when unchanged. Called at
      *  session_start and on every context event so config edits apply live. */
     reloadConfig(cwd: string): Promise<void>;
-    stateFor(ctx: ExtensionContext, liveMessages?: AgentMessage[]): Promise<{
+    stateFor(ctx: ExtensionContext): Promise<{
         state: CompressionState;
         coreMessages: ReturnType<typeof entriesToCoreMessages>;
         entries: SessionEntry[];
@@ -129,16 +109,6 @@ export interface AcpRuntime {
      *  holds the full projected CoreMessage[] for the session history. */
     dropProjectionCache(sid: string): void;
     save(state: CompressionState, ctx: ExtensionContext): Promise<void>;
-    /** #364 inline child sessions (same process, e.g. Prime RLM): derive the
-     *  child's compression state from another session's. Inherits blocks /
-     *  message refs / token snapshot so decompress + search_context keep working
-     *  on inherited blocks; resets every rhythm ledger (nudge cadence, stats,
-     *  absorb). One-time: writes a derivation marker into the child sidecar and
-     *  refuses to run again; also refuses when the child already owns real
-     *  (non-derived) blocks or when the parent has no blocks. Separate-process
-     *  pi-native delegates must NOT call this — their parentSession header
-     *  already inherits verbatim. Returns true when the child state was derived. */
-    deriveChildState(child: SessionRef, parent: SessionRef): Promise<boolean>;
     acquireLock(sid: string): Promise<() => void>;
     /** Per-session overflow self-heal state (learned window + armed emergency).
      *  Keyed by session id so concurrent sessions cannot share an episode. */

package/dist/session-log.d.ts

@@ -2,22 +2,11 @@ import type { SessionEntry } from "@earendil-works/pi-coding-agent";
 /** Parse a session jsonl into entries — mirrors pi's own loadEntriesFromFile
  *  (JSON.parse per line; blank and malformed lines skipped). */
 export declare function parseSessionLog(text: string): SessionEntry[];
-/** Read-only lookup of entries in ANCESTOR sessions (issue #531): a derived
- *  child session (Prime RLM inline) inherits blocks whose message ids exist
- *  only in the parent's session log, so decompress must fall back up the
- *  parentSession header chain. Walks upward from `sessionFile` (nearest
+/** Read-only lookup of entries in ANCESTOR sessions (issue #531): a session
+ *  that inherited its parent's blocks through the parentSession header can
+ *  cover message ids that exist only in the parent's session log, so
+ *  decompress must fall back up the parentSession header chain. Walks upward from `sessionFile` (nearest
  *  ancestor first), cycle-safe and depth-capped like state inheritance, and
  *  returns entries whose base id is in `wantedBaseIds`. The starting session
  *  itself is never included; nearest-ancestor entries win on duplicate ids. */
 export declare function loadAncestorEntries(sessionFile: string | undefined, wantedBaseIds: Set<string>): Promise<SessionEntry[]>;
-/** Read-only content recovery for content-addressed `live-*` refs (issue
- *  #579): fork hosts alias not-yet-persisted tail messages with `live-*` ids
- *  (runtime.ts mergeLiveEntries); those aliases appear in NO jsonl, so the
- *  entry-id lookup above can never find them. The rawId→identity bridge lives
- *  in each session's OWN sidecar (liveRefOrigins). Walks the chain — itself
- *  first, then ancestors, same depth/cycle rules as loadAncestorEntries — and
- *  at each level pairs that level's declared origins with that same level's
- *  log entries matched by messageIdentity. First matching entry wins per rawId
- *  (identical identities are interchangeable: identity covers full normalized
- *  content). Never writes any sidecar. */
-export declare function loadLiveRefEntries(sessionFile: string | undefined, wantedRawIds: Set<string>): Promise<Map<string, SessionEntry>>;

package/dist/state.d.ts

@@ -1,16 +1,5 @@
 import { type CompressionState } from "acp-kernel";
 export declare const STATE_SUFFIX = ".acp.json";
-export interface LiveRefOrigin {
-    rawId: string;
-    identity: string;
-}
-/** One-time marker persisted in a child sidecar when deriveChildState ran
- *  (#364): proves this session's state was explicitly derived from a parent,
- *  so later loads never re-derive. */
-export interface DerivedFrom {
-    parentSessionId: string;
-    derivedAt: number;
-}
 export declare function readParentSessionPath(sessionFile: string): Promise<string | undefined>;
 export declare class SessionStateStore {
     private cache;
@@ -22,23 +11,6 @@ export declare class SessionStateStore {
     setActivePack(sessionFile: string | undefined, sessionId: string, activePack: string): void;
     getActivePack(sessionFile: string | undefined, sessionId: string): string | undefined;
     save(state: CompressionState, sessionFile: string | undefined, sessionId: string): Promise<void>;
-    getLiveRefOrigins(sessionFile: string | undefined, sessionId: string): LiveRefOrigin[];
-    setLiveRefOrigins(sessionFile: string | undefined, sessionId: string, origins: LiveRefOrigin[]): void;
-    getDerivedFrom(sessionFile: string | undefined, sessionId: string): DerivedFrom | null;
-    setDerivedFrom(sessionFile: string | undefined, sessionId: string, mark: DerivedFrom | null): void;
     invalidate(): void;
     private tryLoadParentState;
 }
-/** #364: derive an INLINE child session's compression state from its parent's
- *  (same-process sub-sessions, e.g. Prime RLM). Inherits exactly what makes
- *  inherited blocks usable — blocks (deep-copied: they carry mutable fields),
- *  message refs, the per-message token snapshot, the id counters so new
- *  child blocks cannot collide with inherited ids, and the persistent
- *  acp_rule reminders (kernel cloneState precedent: never silently drop
- *  model-set rules) — and resets every rhythm ledger (nudge cadence
- *  baseline, stats counters, absorb records) so the
- *  child starts its own clock. Separate-process pi-native delegates must NOT
- *  use this: their session files carry a parentSession header that already
- *  inherits the parent state verbatim. */
-export declare function deriveChildState(parent: CompressionState): CompressionState;
-export declare function parseLiveRefOrigins(value: unknown): LiveRefOrigin[];

package/dist/tool-guardrails.d.ts

@@ -1,9 +1,5 @@
 import { type ExtensionAPI, type ToolResultEvent } from "@earendil-works/pi-coding-agent";
 import type { AcpRuntime } from "./runtime.js";
-export type BashToolResultEvent = Extract<ToolResultEvent, {
-    toolName: "bash";
-}>;
-export declare function isBashToolResult(e: ToolResultEvent): e is BashToolResultEvent;
 export declare function resolveBashTimeout(input: {
     timeout?: number;
 }, defaultTimeout: number | undefined): number | undefined;

package/dist/turn-boundary.d.ts

@@ -1,13 +1,6 @@
-/** Single source of truth for turn-boundary decisions (#364).
- *
- * "What counts as a new-turn start" used to be decided independently in three
- * places (per-turn token estimation, turnKey scoping, context-entry
- * projection) and disagreed on host-injected custom_message entries: they
- * enter LLM context but started no turn, so multiple real turns collapsed
- * into one turnKey — nudge ledger cells misaligned, retry-cap and throttle
- * cycle stats distorted, reasoning-drop closing against the wrong turn.
- * Every turn-boundary check in the adapter goes through isTurnBoundary.
- */
+/** Single source of truth for turn-boundary decisions (#364): per-turn token
+ *  estimation, turnKey scoping and compress-outcome scoping all ask the same
+ *  question. A turn starts at a genuine user-role message. */
 /** Minimal structural shape of a session-log entry for boundary checks. Pi's
  *  SessionEntry and the narrower arrays used by token accounting both satisfy
  *  it without casts. */
@@ -20,34 +13,12 @@ export interface TurnBoundaryEntry {
         role?: string;
     };
 }
-/** Host multi-session policy (#364). Unset/false = pi-native behavior: only
- *  genuine user-role messages start a turn. Inline multi-session hosts (Prime
- *  RLM & co.) inject agent turns as custom_message entries; set
- *  countCustomMessages to make those delimit turns too. Default-off keeps
- *  standalone pi users' nudge cadence unchanged. */
-export interface TurnBoundaryPolicy {
-    countCustomMessages?: boolean;
-    /** #578: optional customType allowlist refining countCustomMessages. When
-     *  set, only injected entries whose customType is listed delimit turns —
-     *  host metadata injections (harness_digest, ipython_state, …) that enter
-     *  LLM context without being a real host turn stay out of turn accounting.
-     *  Unset = every non-empty injected message counts (pre-#578 behavior).
-     *  Entries without a customType never match; UI-only types stay excluded
-     *  even when listed. Ignored unless countCustomMessages is true. */
-    customMessageTypes?: readonly string[];
-}
-/** The ONE turn-boundary predicate (#364): does this entry start a new turn?
- *  Genuine user-role messages always do (pi-native); host-injected
- *  custom_message entries do only when the host opts in via policy, optionally
- *  refined by a customMessageTypes allowlist so metadata injections
- *  (harness_digest, ipython_state) stay out of turn accounting (#578). */
-export declare function isTurnBoundary(entry: TurnBoundaryEntry, policy?: TurnBoundaryPolicy): boolean;
+/** Does this entry start a new turn? */
+export declare function isTurnBoundary(entry: TurnBoundaryEntry): boolean;
 /** Id of the last turn-boundary entry — the per-turn key for nudge
- *  accounting, retry caps and outcome scoping. Defaults to pi-native
- *  boundaries (user-role only); pass a host policy to also count injected
- *  custom_message entries. Returns undefined when no boundary exists yet. */
-export declare function lastTurnBoundaryId(entries: readonly TurnBoundaryEntry[], policy?: TurnBoundaryPolicy): string | undefined;
+ *  accounting, retry caps and outcome scoping. Returns undefined when no
+ *  boundary exists yet. */
+export declare function lastTurnBoundaryId(entries: readonly TurnBoundaryEntry[]): string | undefined;
 /** Index of the last turn-boundary entry — the start of the current turn for
- *  compress-outcome scoping. Same policy semantics as lastTurnBoundaryId;
- *  -1 when no boundary has been seen yet. */
-export declare function lastTurnBoundaryIndex(entries: readonly TurnBoundaryEntry[], policy?: TurnBoundaryPolicy): number;
+ *  compress-outcome scoping; -1 when no boundary has been seen yet. */
+export declare function lastTurnBoundaryIndex(entries: readonly TurnBoundaryEntry[]): number;

package/dist/user-config.d.ts

@@ -1,5 +1,5 @@
 import type { Prompts } from "acp-kernel";
-import type { AdapterConfig, CompressConfig, HostSessionConfig, RepetitionGuardConfig } from "./config.js";
+import type { AdapterConfig, CompressConfig, RepetitionGuardConfig } from "./config.js";
 import type { PiPromptSections } from "./system-prompt.js";
 import type { NudgeSectionsConfig, ToolPromptsConfig } from "./surface.js";
 import type { DegenerationGuardConfig } from "./degeneration.js";
@@ -29,7 +29,6 @@ export interface UserAcpConfig {
     promptSections?: PiPromptSections;
     nudgeSections?: NudgeSectionsConfig;
     toolPrompts?: ToolPromptsConfig;
-    hostSession?: boolean | HostSessionConfig;
     rules?: boolean;
     compressionModelId?: string;
 }

package/lean/index.ts

@@ -29,7 +29,7 @@ function decorateWithCollapsedDisplay<T extends CollapsedDisplayTool>(tool: T):
 
 // Resident rules only: what the model must know before any ACP call. Guidance
 // needed after a call already arrives with it — nudges (what/how to compress),
-// compress errors (live refs, acp_status), decompress results (file path),
+// compress errors (valid refs, acp_status), decompress results (file path),
 // the throttle retry message, acp_context help and arg errors. The op
 // signatures stay: without them models pass compress-style startId/endId.
 const LEAN_SYSTEM_PROMPT = `ACP context management

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "billion-context-pi-lean",
-	"version": "0.2.0",
+	"version": "0.2.1",
 	"description": "Lean fork of billion-context-pi for Pi: long-session context compression with an optional cheap summary model — 486 initialization tokens, 94% fewer than the original.",
 	"main": "dist/index.js",
 	"types": "dist/index.d.ts",

package/dist/compat.d.ts

@@ -1,23 +0,0 @@
-import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
-/**
- * Host compatibility layer for pi vs omp (oh-my-pi) API differences.
- *
- * pi: systemPrompt is string, getSystemPrompt() returns string
- * omp: systemPrompt is string[], getSystemPrompt() returns string[]
- *
- * These helpers normalize the differences so the rest of the codebase
- * can work with a consistent string interface.
- */
-/** Normalize systemPrompt to a single string (join with newlines if array). */
-export declare function normalizeSystemPrompt(input: string | string[] | undefined): string;
-/**
- * Format systemPrompt for before_agent_start event handler.
- * Always returns string to satisfy pi's type definition, but handles
- * both string (pi) and string[] (omp) input types at runtime.
- */
-export declare function formatSystemPromptForEvent(base: string | string[], append: string): string;
-/**
- * Get the system prompt as a single string, regardless of host type.
- * Handles both pi (string) and omp (string[]) return types.
- */
-export declare function getSystemPromptText(ctx: ExtensionContext): string;

package/dist/host.d.ts

@@ -1,15 +0,0 @@
-import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
-/** Which session-entry source API the host exposes (same precedence as readContextEntries). */
-export type EntrySourceKind = "buildContextEntries" | "getBranch";
-export declare function entrySourceOf(sm: ExtensionContext["sessionManager"]): EntrySourceKind | null;
-/**
- * Whether the host declared itself a Pi-compatible fork via environment.
- *
- * The SessionManager shape alone cannot distinguish e.g. Prime from OMP — both are
- * Pi forks exposing `getBranch()` but not `buildContextEntries()` — so an
- * unsupported shape requires an explicit declaration before the adapter runs.
- * Read at call time so hosts can set it per-launch. See docs/host-adapter.md.
- */
-export declare function isDeclaredForkHost(): boolean;
-/** Unsupported host: not Pi-shaped and not declared as a fork. OMP stays blocked by default. */
-export declare function isUnsupportedHost(sm: ExtensionContext["sessionManager"]): boolean;

package/dist/omp.d.ts

@@ -1,19 +0,0 @@
-/**
- * Shown (and logged) when the extension detects an unsupported host and stands down.
- *
- * Unsupported = no Pi `buildContextEntries()` API AND no `PI_ACP_FORK_HOST` declaration
- * (see ./host.ts). OMP (oh-my-pi) falls into this by default: its in-process live-entries
- * integration diverges the nudge's example refs from the session's real refs, so compress
- * calls fail with "does not exist in this session" ([#234]). The billion-context proxy runs
- * compression server-side (it owns the ref coordinate space) and works on OMP.
- */
-export declare const UNSUPPORTED_HOST_MESSAGE: string;
-/**
- * Shown (and logged) when a session runs on a host that declared itself a
- * Pi-compatible fork via PI_ACP_FORK_HOST (see ./host.ts). Live-tail refs are
- * content-addressed and stable across context fires (#459), which assumes the
- * host's view of the session grows append-only; a host that rewrites or
- * shrinks in-flight messages can still drift refs, so long sessions on such
- * hosts are safer on the proxy (it owns the ref coordinate space server-side).
- */
-export declare const FORK_HOST_WARNING_MESSAGE: string;

package/dist/sequence-match.d.ts

@@ -1,7 +0,0 @@
-export interface MatchRange {
-    candidateStart: number;
-    liveStart: number;
-    length: number;
-}
-export declare function findUniqueLongestRun<Key>(candidates: readonly Key[], live: readonly Key[]): MatchRange | undefined;
-export declare function findPositionalPrefixRun<Key>(candidates: readonly Key[], live: readonly Key[]): MatchRange | undefined;