billion-context-pi-lean 0.1.69-lean.1 → 0.2.0

package/dist/search-tool.d.ts

@@ -0,0 +1,10 @@
+import { Type } from "typebox";
+import type { ToolDefinition } from "@earendil-works/pi-coding-agent";
+import type { AcpRuntime } from "./runtime.js";
+import { type ToolPromptOverrides } from "./surface.js";
+declare const SearchParams: Type.TObject<{
+    query: Type.TString;
+    limit: Type.TOptional<Type.TNumber>;
+}>;
+export declare function makeSearchTool(runtime: AcpRuntime, overrides?: ToolPromptOverrides): ToolDefinition<typeof SearchParams>;
+export {};

package/dist/sequence-match.d.ts

@@ -0,0 +1,7 @@
+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;

package/dist/session-log.d.ts

@@ -0,0 +1,23 @@
+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
+ *  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-rebuild.d.ts

@@ -0,0 +1,30 @@
+import type { CompressionCore, CompressionState } from "acp-kernel";
+import type { SessionEntry } from "@earendil-works/pi-coding-agent";
+type ApplyInput = Parameters<CompressionCore["applyCompression"]>[0];
+export interface RebuildReport {
+    blocks: number;
+    callsApplied: number;
+    callsSkipped: number;
+    errors: string[];
+}
+export interface RebuildResult {
+    state: CompressionState;
+    report: RebuildReport;
+}
+/** Cheap scan: does this log contain at least one non-error compress toolResult? */
+export declare function hasCompressHistory(entries: SessionEntry[]): boolean;
+/**
+ * Replay successful compress calls from the session log against `state`
+ * (normally a fresh createInitialState()). Failed, errored, no-op and
+ * unparseable calls are skipped — applyCompression batches are atomic, so a
+ * rejected call leaves state untouched. `report.blocks` tells the caller
+ * whether anything was actually rebuilt (state is returned unchanged when
+ * nothing applied).
+ */
+export declare function rebuildStateFromLog(input: {
+    entries: SessionEntry[];
+    state: CompressionState;
+    config: ApplyInput["config"];
+    core: CompressionCore;
+}): RebuildResult;
+export {};

package/dist/state.d.ts

@@ -0,0 +1,44 @@
+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;
+    private writes;
+    private tmpSeq;
+    load(sessionFile: string | undefined, sessionId: string): Promise<CompressionState>;
+    /** Stamp the effective prompt pack for the live session (audit trail:
+     *  persisted into the sidecar on the next save). */
+    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/status-tool.d.ts

@@ -0,0 +1,13 @@
+import { Type } from "typebox";
+import type { ToolDefinition } from "@earendil-works/pi-coding-agent";
+import type { AcpRuntime } from "./runtime.js";
+import { type ToolPromptOverrides } from "./surface.js";
+declare const StatusParams: Type.TObject<{
+    scope: Type.TOptional<Type.TUnion<[Type.TLiteral<"compressed">, Type.TLiteral<"uncompressed">]>>;
+    view: Type.TOptional<Type.TUnion<[Type.TLiteral<"ranges">, Type.TLiteral<"messages">]>>;
+    tool: Type.TOptional<Type.TString>;
+    sort: Type.TOptional<Type.TUnion<[Type.TLiteral<"size">, Type.TLiteral<"time">, Type.TLiteral<"tool">, Type.TLiteral<"age">]>>;
+    limit: Type.TOptional<Type.TNumber>;
+}>;
+export declare function makeStatusTool(runtime: AcpRuntime, overrides?: ToolPromptOverrides): ToolDefinition<typeof StatusParams>;
+export {};

package/dist/strip-images.d.ts

@@ -0,0 +1,18 @@
+import type { StripProtocol } from "acp-kernel/wire";
+/** Map pi-ai's Api id to the kernel wire dialect. Only dialects the kernel
+ *  strip primitive explicitly supports are mapped; everything else returns
+ *  null (= no-op), so exotic or future APIs are never mangled. */
+export declare function apiToStripProtocol(api: string | undefined): StripProtocol;
+export interface StripImagesOutcome {
+    /** Replacement body to send, or undefined when the payload is unchanged. */
+    body?: unknown;
+    /** Number of image parts removed (0 = untouched). */
+    removed: number;
+}
+/** Strip historical images from a provider request body. Pure: returns
+ *  { removed: 0 } (and NO body) when disabled, the protocol is unsupported,
+ *  the body is not strip-shaped, or nothing is older than keepRecent. */
+export declare function applyStripImages(body: unknown, api: string | undefined, settings: {
+    enabled: boolean;
+    keepRecent: number;
+}): StripImagesOutcome;

package/dist/summary-sanitize.d.ts

@@ -0,0 +1,8 @@
+export declare function countUnicodeEscapes(s: string): number;
+export declare function decodeUnicodeEscapes(s: string): string;
+export declare const UNESCAPE_THRESHOLD = 20;
+export declare function sanitizeSummary(s: string): {
+    text: string;
+    unescaped: boolean;
+};
+export declare function findUnverifiableUserQuote(summary: string): string | null;

package/dist/surface.d.ts

@@ -0,0 +1,17 @@
+import type { TSchema } from "typebox";
+import type { ToolDefinition } from "@earendil-works/pi-coding-agent";
+import type { AdapterConfig } from "./config.js";
+export interface ToolPromptOverrides {
+    description?: string;
+    paramDescriptions?: Record<string, string>;
+    promptSnippet?: string;
+    promptGuidelines?: string | string[];
+}
+export type AcpToolName = "compress" | "decompress" | "search_context" | "acp_status" | "acp_cache";
+export type ToolPromptsConfig = Partial<Record<AcpToolName, ToolPromptOverrides>>;
+export type NudgeSectionsConfig = Partial<Record<"efficiencyNote" | "emergencyHeader" | "t2Guidance" | "t3Guidance", string | null>>;
+export declare function sanitizeToolPrompts(raw: unknown): ToolPromptsConfig;
+export declare function sanitizeNudgeSections(raw: unknown): NudgeSectionsConfig;
+export declare function applyToolPromptOverrides<TParams extends TSchema>(def: ToolDefinition<TParams>, overrides?: ToolPromptOverrides): ToolDefinition<TParams>;
+export declare function readToolSurfaceSync(cwd: string): ToolPromptsConfig;
+export declare function sanitizeSurfaceConfig(adapter: AdapterConfig): AdapterConfig;

package/dist/system-passthrough.d.ts

@@ -0,0 +1,4 @@
+import type { SessionMessageEntry } from "@earendil-works/pi-coding-agent";
+type AgentMessage = SessionMessageEntry["message"];
+export declare function carryHostSystemMessages(rebuilt: AgentMessage[], input: AgentMessage[]): AgentMessage[];
+export {};

package/dist/system-prompt.d.ts

@@ -0,0 +1,20 @@
+import type { Prompts } from "acp-kernel";
+import { type SectionOverride } from "acp-kernel";
+export interface PiPromptSections {
+    acpTags?: SectionOverride;
+    summariesInContext?: SectionOverride;
+    tools?: SectionOverride;
+    whenToCompress?: SectionOverride;
+    whenNotToCompress?: SectionOverride;
+    multiTierIntro?: SectionOverride;
+    decompressPhilosophy?: SectionOverride;
+    contextBreakdown?: SectionOverride;
+    throttleRetry?: SectionOverride;
+    philosophy?: SectionOverride;
+    howToCompress?: SectionOverride;
+    tier2?: SectionOverride;
+    tier3?: SectionOverride;
+}
+export declare const SECTION_KEYS: ReadonlySet<string>;
+export declare function sanitizePromptSections(raw: unknown): Partial<PiPromptSections>;
+export declare function buildAcpSystemPrompt(prompts: Prompts, sections?: Partial<PiPromptSections>): string;

package/dist/tag-tokens.d.ts

@@ -0,0 +1,3 @@
+export declare function formatTokens(tokens: number): string;
+export declare function stableTagTokens(text: string): string;
+export declare function rewriteTagTokens(tag: string, body: string): string;

package/dist/throttle-retry.d.ts

@@ -0,0 +1,52 @@
+export declare const THROTTLE_RETRY_ERROR_MESSAGE = "429 rate limit: Too many tokens, please wait before trying again.";
+export declare const THROTTLE_KICK_SENTINEL = "[ACP:provider-throttle]";
+export declare const THROTTLE_KICK_TEXT = "[ACP:provider-throttle] The previous assistant response was interrupted by a provider rate limit (transient, not a real failure). Resume the task exactly where it left off \u2014 do not re-run completed steps and do not discuss the interruption unless asked.";
+export interface ThrottleErrorProbe {
+    role: string;
+    stopReason?: string;
+    errorMessage?: string;
+    content: unknown;
+}
+export declare function isThrottleError(msg: ThrottleErrorProbe): boolean;
+export declare function isKickMessage(msg: {
+    role: string;
+    content: unknown;
+}): boolean;
+export interface ThrottleRetryConfig {
+    enabled?: boolean;
+    maxRetries?: number;
+    baseDelayMs?: number;
+    maxDelayMs?: number;
+    backoffMode?: "exponential" | "fixed";
+}
+export interface ResolvedThrottleRetry {
+    enabled: boolean;
+    maxRetries: number;
+    baseDelayMs: number;
+    maxDelayMs: number;
+    backoffMode: "exponential" | "fixed";
+}
+export declare const DEFAULT_THROTTLE_RETRY: ResolvedThrottleRetry;
+export declare function resolveThrottleRetry(cfg: boolean | ThrottleRetryConfig | undefined): ResolvedThrottleRetry;
+export declare function throttleDelayMs(kickNumber: number, r: ResolvedThrottleRetry): number;
+export interface ThrottleEpisodeState {
+    attempts: number;
+    kicks: number;
+    candidate: boolean;
+}
+export declare const INITIAL_THROTTLE_STATE: ThrottleEpisodeState;
+export declare class ThrottleEpisode {
+    state: ThrottleEpisodeState;
+    private cancel;
+    reset(): void;
+    onProgress(): void;
+    onUserMessage(kick: boolean): void;
+    onThrottleError(maxRetries: number): "rewrite" | "exhausted";
+    onNonThrottleError(): void;
+    readyToKick(maxRetries: number): boolean;
+    onKickStarted(): void;
+    onKickCancelled(): void;
+    sleepController(): AbortController;
+    cancelSleep(): void;
+}
+export declare function abortableSleep(ms: number, signal: AbortSignal): Promise<"ok" | "aborted">;

package/dist/tokens.d.ts

@@ -0,0 +1,61 @@
+import { type CompressionCore, type CompressionState, type Config, type CoreMessage } from "acp-kernel";
+import type { SessionMessageEntry } from "@earendil-works/pi-coding-agent";
+type AgentMessage = SessionMessageEntry["message"];
+export declare function collectCoveredMessageIds(state: {
+    blocks: {
+        active: boolean;
+        effectiveMessageIds: string[];
+    }[];
+}): Set<string>;
+export declare const IMAGE_TOKEN_COST = 1600;
+export declare function modelSupportsImages(model: unknown): boolean;
+export declare function collectImageTokens(entries: {
+    id: string;
+    type?: string;
+    message?: AgentMessage;
+}[], visionCapable: boolean): Map<string, number>;
+export declare function estimateTokens(messages: CoreMessage[], coveredIds?: Set<string>, imageTokensById?: Map<string, number>): number;
+export declare function sentViewTokenCount(core: CompressionCore, messages: CoreMessage[], state: CompressionState, config: Config, prelim: number, imageTokensById?: Map<string, number>, systemPromptTokens?: number): {
+    viewTokens: number;
+    drifted: boolean;
+};
+export declare function adjustedTokenCount(core: CompressionCore, messages: CoreMessage[], state: CompressionState, config: Config, prelim: number, imageTokensById?: Map<string, number>, systemPromptTokens?: number): number;
+/** Per-session record of the EXACT sent view measured off the previous real
+ *  processTurn output (issue #561) — replaces re-running a probe processTurn
+ *  (clone + full second pass over the whole history) on every steady-state
+ *  turn. */
+export interface SentViewMeterRecord {
+    viewTokens: number;
+    /** The raw (pre-prune) estimate of the same turn, on the sentTokens scale.
+     *  Lean: the next turn adds its raw growth since then to viewTokens. */
+    rawTokens: number;
+    /** blockSignature() of the state the view was measured on. */
+    blockSig: string;
+    /** historyCanary() of the projected messages the view was measured on. */
+    history: HistoryCanary;
+    limit: number;
+    /** False when the measured view may be dishonest (post-truncation output,
+     *  or the record is absent) — callers must then run the full probe. */
+    usable: boolean;
+}
+/** Block count plus each active block's id, coverage size, run, tier and
+ *  summary length: a decompress + compress pair, an absorb that keeps the
+ *  active count, or an in-place refold (same id and coverage, rewritten
+ *  summary) still changes it. Length suffices — only the size is metered. */
+export declare function blockSignature(state: CompressionState): string;
+export interface HistoryCanary {
+    count: number;
+    firstId: string | null;
+    lastId: string | null;
+}
+export declare function historyCanary(messages: CoreMessage[]): HistoryCanary;
+/** Signature check for adopting the previous turn's measured view (issue #561):
+ *  the meter describes LAST turn's (state, config, history); it is only
+ *  transferable when nothing structural moved — same window, same block
+ *  signature, history only appended to — and the raw estimate did not shrink.
+ *  Pure function, unit-testable. */
+export declare function sentViewMeterMatches(meter: SentViewMeterRecord | undefined, state: CompressionState, config: Config, rawTokens: number, messages: CoreMessage[]): boolean;
+/** Lean: the previous view plus everything appended since. Adopting the bare
+ *  previous viewTokens dropped the new messages' growth from the meter. */
+export declare function adoptedViewTokens(meter: SentViewMeterRecord, rawTokens: number): number;
+export {};

package/dist/tool-guardrails.d.ts

@@ -0,0 +1,33 @@
+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;
+export declare function capToolOutput(content: ToolResultEvent["content"], maxBytes: number | undefined, fullPath?: string): ToolResultEvent["content"] | undefined;
+export declare function detectBashTimeout(content: ToolResultEvent["content"]): number | undefined;
+export declare function appendTimeoutNotice(content: ToolResultEvent["content"], secs: number): ToolResultEvent["content"];
+export declare function canonicalStringify(value: unknown): string;
+export declare function repetitionFingerprint(toolName: string, input: unknown): string;
+export type RepetitionAction = "none" | "warn" | "abort";
+export interface RepetitionDecision {
+    action: RepetitionAction;
+    count: number;
+    fingerprint: string;
+    toolName: string;
+}
+export declare class RepetitionTracker {
+    private readonly thresholds;
+    private lastFp;
+    private count;
+    constructor(thresholds: {
+        warn: number;
+        abort: number;
+    });
+    note(toolName: string, input: unknown): RepetitionDecision;
+    reset(): void;
+}
+export declare function wireToolGuardrails(pi: ExtensionAPI, runtime: AcpRuntime): void;

package/dist/tool-pair-sanitizer.d.ts

@@ -0,0 +1,8 @@
+import type { SessionMessageEntry } from "@earendil-works/pi-coding-agent";
+type AgentMessage = SessionMessageEntry["message"];
+export interface ToolPairSanitizeResult {
+    messages: AgentMessage[];
+    droppedResults: string[];
+}
+export declare function sanitizeToolPairing(messages: AgentMessage[]): ToolPairSanitizeResult;
+export {};

package/dist/turn-boundary.d.ts

@@ -0,0 +1,53 @@
+/** 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.
+ */
+/** 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. */
+export interface TurnBoundaryEntry {
+    type?: string;
+    id?: string;
+    customType?: string;
+    content?: unknown;
+    message?: {
+        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;
+/** 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;
+/** 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;

package/dist/user-config.d.ts

@@ -0,0 +1,67 @@
+import type { Prompts } from "acp-kernel";
+import type { AdapterConfig, CompressConfig, HostSessionConfig, RepetitionGuardConfig } from "./config.js";
+import type { PiPromptSections } from "./system-prompt.js";
+import type { NudgeSectionsConfig, ToolPromptsConfig } from "./surface.js";
+import type { DegenerationGuardConfig } from "./degeneration.js";
+import type { ThrottleRetryConfig } from "./throttle-retry.js";
+import type { IdleCompactConfig } from "./idle-compact.js";
+/** User-facing config keys (subset of AdapterConfig). Loaded from
+ *  ~/.<CONFIG_DIR_NAME>/acp.json (global) and <cwd>/.<CONFIG_DIR_NAME>/acp.json
+ *  (project-local overrides project-global). Project wins over global. */
+export interface UserAcpConfig {
+    enabled?: boolean;
+    debug?: boolean;
+    modelContextLimit?: number;
+    protectedTools?: string[];
+    protectedLatestTools?: string[];
+    neverPreserveRecentTools?: string[];
+    preserveRecentTools?: string[];
+    toolBashDefaultTimeout?: number;
+    toolOutputMaxBytes?: number;
+    compress?: CompressConfig;
+    outputHeadroomMaxPct?: number | string;
+    throttleRetry?: boolean | ThrottleRetryConfig;
+    idleCompact?: boolean | IdleCompactConfig;
+    repetitionGuard?: boolean | RepetitionGuardConfig;
+    degenerationGuard?: boolean | DegenerationGuardConfig;
+    prompts?: Partial<Prompts>;
+    acknowledgePromptsRisk?: boolean;
+    promptSections?: PiPromptSections;
+    nudgeSections?: NudgeSectionsConfig;
+    toolPrompts?: ToolPromptsConfig;
+    hostSession?: boolean | HostSessionConfig;
+    rules?: boolean;
+    compressionModelId?: string;
+}
+/** Read global + project acp.json, project overrides global. Returns {} on any
+ *  error (missing file, bad JSON) — never throws. Malformed-but-repairable
+ *  files are salvaged with a loud warning instead of silently meaning "not
+ *  disabled" / "no config" (#467). */
+export declare function loadUserConfig(cwd: string): Promise<UserAcpConfig>;
+export interface AcpJsonParse {
+    status: "ok" | "repaired" | "failed";
+    value?: Record<string, unknown>;
+    reason?: string;
+}
+/** Lenient parse of a hand-edited acp.json (#467): strict JSON first, then
+ *  repair the common hand-edit shapes (BOM head, trailing commas, unquoted
+ *  keys) with a loud warning, then give up with a diagnosed reason. The
+ *  enabled:false master switch must survive a notepad edit — silently
+ *  treating the user's file as absent is the exact opposite of intent. */
+export declare function parseAcpJson(file: string, raw: string): AcpJsonParse;
+/** Merge user config onto an adapter config: user config wins for the keys it
+ *  sets. Used at session_start to apply runtime-discovered config. The two
+ *  protection keys are shape-checked here because acp.json is hand-edited JSON
+ *  and a malformed value must warn + fall back, never fail the session or feed
+ *  garbage to the kernel (#499). */
+export declare function applyUserConfig(adapter: AdapterConfig, user: UserAcpConfig): AdapterConfig;
+/** Persist compressionModelId in the GLOBAL acp.json while preserving every
+ *  other key (#241 port, `/acp compact`). null removes it. Project-level
+ *  acp.json still overrides the global value. A present-but-unparseable file
+ *  is never overwritten. */
+export declare function saveCompressionModelId(value: string | null): Promise<void>;
+/** Read-modify-write the GLOBAL acp.json, keeping every key the mutator does
+ *  not touch. A present-but-unparseable file is never overwritten. Calls are
+ *  serialized so quick successive changes (settings panel) never read the same
+ *  old snapshot and drop each other. */
+export declare function updateGlobalAcpConfig(mutate: (current: Record<string, unknown>) => void): Promise<void>;