@retaw106/mmc-oc 0.0.0-stage → 1.2.2

package/dist/hooks/magic-context/ctx-reduce-availability.d.ts

@@ -0,0 +1,170 @@
+import type { PluginContext } from "../../plugin/types";
+/**
+ * Whether a given tool is actually CALLABLE in a session's tool set.
+ *
+ * Magic Context registers tools process-globally, but a parent agent (or the
+ * user's OpenCode config) can spawn a session with an explicit allow-list
+ * tools map ({"*": false, read: true, ...}) that filters a tool out. For such
+ * sessions any surface that urges or replays that tool — mmc_reduce §N§
+ * prefixes and nudges, or synthetic todowrite pairs — is pure overhead urging
+ * a tool the model cannot call (plus cargo-cult risk with no benefit).
+ *
+ * CACHE STABILITY: the verdict is resolved ONCE per session per tool from the
+ * FIRST user message's tools map and cached for the process lifetime. Per-turn
+ * tool maps can differ (mode switches toggle edit tools), and a flapping
+ * verdict would oscillate provider-visible bytes — a per-turn HARD bust. The
+ * first-message map is fixed at session spawn, so the verdict is deterministic
+ * across passes and restarts.
+ *
+ * OpenCode does not write agent or session permissions into the first user
+ * message's tools map, so a session whose agent config (or session permission
+ * overlay) denies mmc_reduce would otherwise freeze as "callable". To cover it,
+ * whichever hook runs first on a session (the messages transform or the
+ * system-prompt hook; OpenCode may run either first) reads those permissions
+ * ONCE, before the mmc_reduce verdict first freezes (see
+ * primeCtxReduceSpawnPermission). A deny recorded there makes
+ * the frozen verdict "unavailable" from the session's first pass, so no
+ * provider-visible byte ever flips.
+ *
+ * After the verdict freezes it never changes again, even when OpenCode's live
+ * permission rules later deny the tool. Its value gates guidance and the
+ * system-prompt hash; changing it mid-session would invalidate the provider
+ * prefix for a permission change that is otherwise not part of the prompt. A
+ * mid-session deny is only logged. Todowrite's synthetic pair has a separate
+ * live permission check at cache-busting boundaries, so this asymmetry is
+ * deliberate and load-bearing.
+ *
+ * Fail-open: no tools map (normal sessions), no wildcard-deny, no recorded
+ * permission deny, or an unreadable OpenCode DB all resolve to "available" —
+ * current behavior.
+ */
+/** Availability verdict plus whether it is final for the session's lifetime. */
+export interface ToolAvailabilityVerdict {
+    callable: boolean;
+    /** True when resolved from the session's first user message (cached).
+     *  False when the verdict is a provisional fail-open default — consumers
+     *  that PERSIST state derived from the verdict (e.g. the system-prompt
+     *  hash) must skip persistence until a frozen verdict exists, or a later
+     *  final verdict flips the persisted bytes and busts the prompt cache. */
+    frozen: boolean;
+}
+/**
+ * Set whether `mmc_reduce` is registered process-globally. Called once at
+ * plugin boot from the tool registry resolution. When false, every
+ * `resolveCtxReduceAvailability*` call returns a frozen `callable: false`
+ * verdict without consulting the per-session tools map or the OpenCode DB.
+ */
+export declare function setCtxReduceRegisteredGlobally(registered: boolean): void;
+/** Test-only reset so the availability suite's default-true baseline is
+ *  unaffected by a prior test that flipped the override. Production code
+ *  never needs to re-enable mid-process (boot-resolved, process-stable). */
+export declare function resetCtxReduceRegisteredGloballyForTest(): void;
+/** Historical alias. mmc_reduce was the first consumer of this resolver; the
+ * verdict shape is identical for every tool, so the name is kept so existing
+ * mmc_reduce call sites stay untouched.
+ */
+export type CtxReduceAvailabilityVerdict = ToolAvailabilityVerdict;
+type PermissionAction = "ask" | "allow" | "deny";
+/** The small rule shape used by OpenCode's Permission.disabled evaluator. */
+export interface PermissionRule {
+    permission: string;
+    pattern: string;
+    action: PermissionAction;
+}
+/**
+ * Resolve from the in-memory transform message array (preferred — free).
+ * Caches the verdict on first resolution.
+ */
+export declare function resolveToolAvailabilityFromMessages(sessionId: string, toolName: string, messages: ReadonlyArray<{
+    info?: {
+        role?: string;
+        tools?: unknown;
+    };
+}>): ToolAvailabilityVerdict;
+/**
+ * Resolve from the OpenCode DB (paths that may run before the transform has
+ * seen any messages — e.g. the system-prompt hook, or tool.execute.after).
+ * Falls back to "available" when the DB is absent (Pi-only installs) or the
+ * read fails.
+ */
+export declare function resolveToolAvailability(sessionId: string, toolName: string): ToolAvailabilityVerdict;
+/** Drop a cached verdict for one tool of one session (test/reset helper). */
+export declare function clearToolAvailability(sessionId: string, toolName: string): void;
+export declare function resolveCtxReduceAvailabilityFromMessages(sessionId: string, messages: ReadonlyArray<{
+    info?: {
+        role?: string;
+        tools?: unknown;
+    };
+}>): CtxReduceAvailabilityVerdict;
+export declare function resolveCtxReduceAvailability(sessionId: string): CtxReduceAvailabilityVerdict;
+export declare function clearCtxReduceAvailability(sessionId: string): void;
+/**
+ * Apply OpenCode's Permission.disabled rule: the last matching permission
+ * rule wins, and only a deny of the whole permission pattern disables it.
+ * Keeping this evaluator pure makes the findLast behavior testable without a
+ * live OpenCode server.
+ */
+export declare function permissionDisabled(toolName: string, rules: readonly PermissionRule[]): boolean;
+/**
+ * Read OpenCode's merged agent permissions plus the session overlay and apply
+ * the same last-rule evaluator OpenCode uses. The SDK declarations in older
+ * plugin peer versions do not expose the newer permission fields, so the
+ * response is intentionally narrowed at this boundary.
+ */
+export declare function resolveToolPermissionDenied(client: PluginContext["client"], sessionId: string, toolName: string, activeAgent?: string): Promise<boolean>;
+/**
+ * Read the agent and session permissions for mmc_reduce ONCE, before the
+ * session's mmc_reduce verdict first freezes, so a permission deny makes that
+ * first frozen verdict "unavailable" (no §N§ tags, no reduce guidance, no
+ * reduce nudges). OpenCode keeps these permissions on the agent config and the
+ * session, not in the first user message's tools map, so the tools-map resolver
+ * alone cannot see them.
+ *
+ * Callers must await this before calling a resolveCtxReduceAvailability*
+ * function on a pass that may freeze the verdict. Once the verdict is frozen
+ * this is a no-op: a later permission change must not flip provider-visible
+ * bytes. `spawnAgent` should be the agent named on the session's FIRST user
+ * message, so a restart re-reads the same agent even if the user has since
+ * switched agents. A failed read records nothing and the verdict fails open to
+ * "available", exactly as before permissions were considered.
+ */
+export declare function primeCtxReduceSpawnPermission(client: PluginContext["client"], sessionId: string, spawnAgent?: string): Promise<void>;
+/**
+ * Cheap check (no I/O) for whether a pre-freeze permission read would still do
+ * anything: false once the verdict froze or a read already recorded a result.
+ */
+export declare function ctxReduceSpawnPermissionReadNeeded(sessionId: string): boolean;
+/** Agent named on the session's first user message (the agent it was spawned with). */
+export declare function spawnAgentFromMessages(messages: ReadonlyArray<{
+    info?: {
+        role?: string;
+        agent?: unknown;
+    };
+}>): string | undefined;
+/**
+ * Spawn agent read from OpenCode's DB, for callers that run before the
+ * messages transform (OpenCode can run the system-prompt hook first).
+ * `persisted: false` means the session has no stored user message yet, so no
+ * verdict can freeze and no permission read should be recorded. A present
+ * message without an agent reports `agent: undefined`.
+ */
+export declare function spawnAgentFromOpenCodeDb(sessionId: string): {
+    persisted: boolean;
+    agent?: string;
+};
+export declare function todowritePermissionDenied(client: PluginContext["client"], sessionId: string, activeAgent?: string): Promise<boolean>;
+/** Cached live verdict used by defer passes; undefined means no bust has read it yet. */
+export declare function cachedToolPermissionDenied(sessionId: string, toolName: string): boolean | undefined;
+export declare function clearToolPermissionDenied(sessionId: string, toolName?: string): void;
+export declare function hasLoggedCtxReducePermissionDeny(sessionId: string): boolean;
+export declare function markCtxReducePermissionDenyLogged(sessionId: string): void;
+export declare function resolveTodowriteAvailabilityFromMessages(sessionId: string, messages: ReadonlyArray<{
+    info?: {
+        role?: string;
+        tools?: unknown;
+    };
+}>): ToolAvailabilityVerdict;
+export declare function resolveTodowriteAvailability(sessionId: string): ToolAvailabilityVerdict;
+export declare function clearTodowriteAvailability(sessionId: string): void;
+export {};
+//# sourceMappingURL=ctx-reduce-availability.d.ts.map

package/dist/hooks/magic-context/ctx-reduce-availability.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ctx-reduce-availability.d.ts","sourceRoot":"","sources":["../../../src/hooks/magic-context/ctx-reduce-availability.ts"],"names":[],"mappings":"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"}

package/dist/hooks/magic-context/ctx-reduce-nudge.d.ts

@@ -0,0 +1,104 @@
+import { type TailHygieneBaseline, type TailHygienePartMeasurement } from "./tail-hygiene-walk";
+export type Channel1Level = "gentle" | "firm" | "urgent";
+export interface ToolReclaimHint {
+    tagNumber: number;
+    toolName: string | null;
+}
+export interface Channel1State extends TailHygieneBaseline {
+    usableWindow: number;
+    /** Monotonic count of real (not Magic Context-injected) user turns in this pass. */
+    realUserTurnCount: number;
+    reducedSinceRefresh: boolean;
+    /** Do not trigger a reduction nudge on the pass that applied queued agent drops. */
+    agentDropsAppliedThisPass?: boolean;
+    oldestReclaimableToolTags: ToolReclaimHint[];
+}
+export declare const CHANNEL1_SENTINEL = "<system-reminder>";
+export declare const TOKENS_PER_BYTE = 0.25;
+export declare const CHANNEL1_MIN_TOKENS = 60000;
+export declare const CHANNEL1_FLOOR_TOKENS = 25000;
+export declare const CHANNEL1_REFIRE_FLOOR_TOKENS = 25000;
+export declare const CHANNEL2_SEVERITY_THRESHOLD = 0.75;
+export declare const CHANNEL2_FLOOR_TOKENS = 50000;
+export declare function channel1RefireTokens(tailTokens: number): number;
+export declare function isDroppedToolOutput(output: string): boolean;
+export declare function tailToolTokensFromStrings(outputs: readonly string[]): number;
+export declare function toolOutputTokens(output: string): number;
+export interface TailTokenEstimate {
+    tailToolTokens: number;
+    liveTailTokens: number;
+}
+export type NudgeBand = "quiet" | "gentle" | "firm" | "urgent" | "channel2";
+export declare function nudgeBand(undroppedTokens: number, tailTokens: number): NudgeBand;
+export type Channel1DampeningState = "none" | "baseline-hold" | "post-reduce-grace" | "band-hysteresis" | "cadence" | "sticky-floor";
+export type Channel1VerdictReason = "baseline-unevaluable" | "recent-reduce-refresh" | "agent-drops-applied" | "post-reduce-baseline-pending" | "post-reduce-compliance-grace" | "tail-below-minimum" | "reclaimable-below-floor" | "ratio-below-gentle" | "band-deescalation" | "cadence-growth" | "sticky-turn-floor" | "band-crossing" | "cadence-refire" | "post-reduce-regrowth-reached" | "post-reduce-band-escalation";
+export interface Channel1Decision {
+    fire: boolean;
+    /** Re-fires inside an already-observed band always use the calm one-line copy. */
+    sticky: boolean;
+    level: Channel1Level;
+    band: Exclude<NudgeBand, "channel2">;
+    undroppedTokens: number;
+    tailTokens: number;
+    severity: number;
+    graceBaselineU: number | null;
+    graceGrowth: number;
+    growthThreshold: number;
+    cadenceGrowth: number;
+    stickyTurnsRemaining: number;
+    dampeningState: Channel1DampeningState;
+    verdictReason: Channel1VerdictReason;
+    nextLastNudge: number;
+    /** The currently observed band, not merely the last band that emitted copy. */
+    nextLastNudgeLevel: Channel1Level | "";
+    /** True once post-reduce grace has ended and its durable fields should be cleared. */
+    clearPostReduceGrace: boolean;
+}
+export declare function decideChannel1(input: {
+    baselineU: number;
+    baselineT: number;
+    turnDeltaU: number;
+    turnDeltaT: number;
+    lastNudgeUndropped: number;
+    lastNudgeLevel: Channel1Level | "";
+    lastFireOrdinal?: number;
+    currentRealUserTurnCount?: number;
+    hasRecentReduce: boolean;
+    agentDropsAppliedThisPass?: boolean;
+    postReduceGracePending?: boolean;
+    postReduceGraceBaselineU?: number;
+    postReduceGracePreLevel?: Channel1Level | "";
+    evaluable?: boolean;
+    generationInvalidated?: boolean;
+}): Channel1Decision;
+export type Channel2PredicateBaseline = Pick<TailHygieneBaseline, "baselineU" | "baselineT" | "turnDeltaU" | "turnDeltaT" | "evaluable" | "generationInvalidated">;
+export type Channel2VerdictReason = "baseline-unavailable" | "baseline-unevaluable" | "generation-invalidated" | "non-finite-input" | "tail-below-minimum" | "reclaimable-below-floor" | "ratio-below-ceiling" | "ceiling-threshold-met";
+export interface Channel2PredicateEvaluation {
+    evaluable: boolean;
+    shouldTrigger: boolean;
+    reclaimableTokens: number;
+    tailTokens: number;
+    severity: number;
+    band: NudgeBand;
+    verdictReason: Channel2VerdictReason;
+}
+export declare function evaluateChannel2(input: Channel2PredicateBaseline | undefined): Channel2PredicateEvaluation;
+export type Channel2LeaseState = "" | "pending" | "claimed" | "delivered";
+export declare function formatChannel1Evaluation(decision: Channel1Decision, ctxReduceCallable?: boolean): string;
+export declare function formatChannel2Evaluation(evaluation: Channel2PredicateEvaluation, input: {
+    ctxReduceCallable?: boolean;
+    leaseBefore: Channel2LeaseState;
+    leaseAfter?: Channel2LeaseState;
+    gateHoldReason?: string;
+}): string;
+export declare function reclaimableToolOutputCount(parts: readonly TailHygienePartMeasurement[]): number;
+export declare function buildChannel2Reminder(undroppedTokens: number, reclaimableToolOutputs: number, hint?: readonly ToolReclaimHint[]): string;
+export declare const CHANNEL1_STICKY_REAL_USER_TURN_GAP = 5;
+export declare function shouldUseStickyChannel1Reminder(input: {
+    lastLevel: Channel1Level | "";
+    lastOrdinal: number;
+    level: Channel1Level;
+    currentRealUserTurnCount: number;
+}): boolean;
+export declare function buildChannel1Reminder(level: Channel1Level, undroppedTokens: number, reclaimableToolOutputs: number, hint?: readonly ToolReclaimHint[], sticky?: boolean): string;
+//# sourceMappingURL=ctx-reduce-nudge.d.ts.map

package/dist/hooks/magic-context/ctx-reduce-nudge.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ctx-reduce-nudge.d.ts","sourceRoot":"","sources":["../../../src/hooks/magic-context/ctx-reduce-nudge.ts"],"names":[],"mappings":"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"}

package/dist/hooks/magic-context/decay-curve.d.ts

@@ -0,0 +1,84 @@
+/**
+ * Deterministic tier-decay curve (v2 cache architecture).
+ *
+ * Pure functions that select which detail tier renders for each compartment,
+ * and which compartments are archived (P5, not rendered). There are TWO
+ * rendered detail tiers: P1 (full narrative) and P4 (decayed — anchor-only
+ * fragment or one compact sentence). The historical P2/P3 paraphrase windows
+ * are fossilized storage layers: the historian no longer emits them, and the
+ * curve renders straight from P1 to P4 across the merged former P2–P4 window.
+ * This REPLACEs the LLM compressor and the per-compartment `compression_depth`
+ * machinery: tier demotion is byte-deterministic at render time, driven by
+ * compartment age, historian-emitted importance (semantically a *decay rate*),
+ * and live budget pressure.
+ *
+ * This is a faithful implementation of the council-validated, empirically-
+ * grounded model documented in `.alfonso/plans/decay-curve-formula.md`, with
+ * the tier ladder collapsed to two detail tiers (boundaries derived from
+ * measured v8.3 Flash tier costs). The model's invariants — age/importance
+ * monotonicity, finite demotion even at importance 100, append stability,
+ * O(H) render cost, and budget self-tuning across model/budget changes — were
+ * independently verified there.
+ *
+ * Anchor overlap (the archive-protection input `o`) is reserved for a future
+ * release: anchors are not a reliable first-class storage primitive today (they
+ * live inline in P4 text), so callers pass `0` and the archive predicate cleanly
+ * reduces to `z >= Z4`. The parameter is kept so the wiring is ready when
+ * anchor extraction lands.
+ */
+/** Half-life (in compartments) for importance 50 at pressure 1. */
+export declare const H50 = 24;
+/** Importance points needed to double the half-life (imp 75 → 2×, 100 → 4×). */
+export declare const D = 25;
+/** Max extra half-lives of P4 protection from full anchor overlap. */
+export declare const G = 2;
+export declare const Z1 = 0.201;
+export declare const Z4 = 2.587;
+/** Pressure floor: prevents div-by-zero and caps relaxation at 10×. */
+export declare const P_FLOOR = 0.1;
+/** Per-tier average token cost, indexed by tier number (1..5). Index 0 unused.
+ * Indices 2/3 are inert fossils: P2/P3 are storage-only layers now, never
+ * selected by `tier()`, and the cost array is kept for byte stability. */
+export declare const TIER_COST: readonly [0, 322, 109, 35, 20, 5];
+export type Tier = 1 | 2 | 3 | 4 | 5;
+/**
+ * Which detail tier a compartment renders at, ignoring archive protection.
+ * Two-tier model: `z < Z1` renders P1 (full); `Z1 <= z < Z4` renders P4
+ * (decayed — the merged former P2–P4 window); `z >= Z4` archives (P5).
+ * @param compartmentIndex 1-based position from newest (1 = newest).
+ * @param importance 1..100 (historian-emitted decay rate).
+ * @param budgetPressure 0.10..∞ (computed once per pass via computeBudgetPressure).
+ */
+export declare function tier(compartmentIndex: number, importance: number, budgetPressure: number): Tier;
+/**
+ * Whether a compartment should be archived (P5, not rendered). Anchor overlap
+ * extends P4 protection by up to G half-lives; with `o = 0` (v2.0 default) this
+ * reduces to `z >= Z4`.
+ */
+export declare function shouldArchive(compartmentIndex: number, importance: number, budgetPressure: number, anchorOverlap?: number): boolean;
+/**
+ * Final rendered tier combining base tier + archive protection. Archived
+ * compartments return 5; anchor-protected ones render at P4 (anchor-only)
+ * instead of P5, preserving the topic until anchor overlap fades.
+ */
+export declare function renderedTier(compartmentIndex: number, importance: number, budgetPressure: number, anchorOverlap?: number): Tier;
+/**
+ * Compute budget pressure for a render pass in a single forward pass. Because
+ * H ∝ 1/p, the count of compartments in each tier also scales as 1/p, so
+ * C(p) ≈ C(1)/p; setting p = C(1)/B gives C(p) ≈ B. Overshoots up to ~30% at
+ * very tight budgets (<8K) — use computeBudgetPressureTwoPass there.
+ */
+export declare function computeBudgetPressure(compartments: ReadonlyArray<{
+    index: number;
+    importance: number;
+}>, historyBudget: number): number;
+/**
+ * Two-pass pressure for tight budgets — converges to within ~1% of budget at
+ * ~2µs extra cost. Recompute actual cost at the single-pass pressure and, if it
+ * still overshoots by >10%, scale pressure proportionally.
+ */
+export declare function computeBudgetPressureTwoPass(compartments: ReadonlyArray<{
+    index: number;
+    importance: number;
+}>, historyBudget: number): number;
+//# sourceMappingURL=decay-curve.d.ts.map

package/dist/hooks/magic-context/decay-curve.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"decay-curve.d.ts","sourceRoot":"","sources":["../../../src/hooks/magic-context/decay-curve.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AAGH,mEAAmE;AACnE,eAAO,MAAM,GAAG,KAAK,CAAC;AACtB,gFAAgF;AAChF,eAAO,MAAM,CAAC,KAAK,CAAC;AACpB,sEAAsE;AACtE,eAAO,MAAM,CAAC,IAAI,CAAC;AAQnB,eAAO,MAAM,EAAE,QAAQ,CAAC;AACxB,eAAO,MAAM,EAAE,QAAQ,CAAC;AAExB,uEAAuE;AACvE,eAAO,MAAM,OAAO,MAAM,CAAC;AAE3B;;0EAE0E;AAC1E,eAAO,MAAM,SAAS,mCAAoC,CAAC;AAE3D,MAAM,MAAM,IAAI,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;AAErC;;;;;;;GAOG;AACH,wBAAgB,IAAI,CAAC,gBAAgB,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,EAAE,cAAc,EAAE,MAAM,GAAG,IAAI,CAY/F;AAED;;;;GAIG;AACH,wBAAgB,aAAa,CACzB,gBAAgB,EAAE,MAAM,EACxB,UAAU,EAAE,MAAM,EAClB,cAAc,EAAE,MAAM,EACtB,aAAa,SAAI,GAClB,OAAO,CAWT;AAED;;;;GAIG;AACH,wBAAgB,YAAY,CACxB,gBAAgB,EAAE,MAAM,EACxB,UAAU,EAAE,MAAM,EAClB,cAAc,EAAE,MAAM,EACtB,aAAa,SAAI,GAClB,IAAI,CAMN;AAED;;;;;GAKG;AACH,wBAAgB,qBAAqB,CACjC,YAAY,EAAE,aAAa,CAAC;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,UAAU,EAAE,MAAM,CAAA;CAAE,CAAC,EAClE,aAAa,EAAE,MAAM,GACtB,MAAM,CAWR;AAED;;;;GAIG;AACH,wBAAgB,4BAA4B,CACxC,YAAY,EAAE,aAAa,CAAC;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,UAAU,EAAE,MAAM,CAAA;CAAE,CAAC,EAClE,aAAa,EAAE,MAAM,GACtB,MAAM,CAYR"}

package/dist/hooks/magic-context/decay-render.d.ts

@@ -0,0 +1,80 @@
+/**
+ * Shared deterministic decay renderer (v2). Used by BOTH OpenCode
+ * (inject-compartments.ts) and Pi (inject-compartments-pi.ts) so the two
+ * harnesses render compartment history byte-identically from the same validated
+ * decay curve. This is the single render-side implementation of the curve in
+ * `decay-curve.ts`; neither harness may keep a private/approximate copy.
+ *
+ * Responsibilities:
+ *  - Pick a tier per compartment from age + importance + budget pressure
+ *    (decay-curve.ts), with budget pressure computed ONCE per pass.
+ *  - Render the chosen detail tier: P1 (full) or P4 (decayed — the merged
+ *    former P2–P4 window); P5 = archived (omitted). p2/p3 are fossil storage
+ *    layers: the tierBody fallback chain keeps tolerating them, but the curve
+ *    never selects them.
+ *  - Legacy (pre-v2, flat-content) compartments: no paraphrase columns, so the
+ *    initial tier is P3 when the body has a `U:` line else P4, and the body is
+ *    truncated `content`.
+ *  - Demote oldest-first under a hard token budget (the curve already fits the
+ *    budget, but this guards against estimate drift / very tight budgets).
+ *
+ * v2 faithful facts: this renderer NEVER emits a <session_facts> block. Facts
+ * are promoted to project memory and render via <project-memory>. Callers pass
+ * the memory block separately; session facts are not a render input.
+ */
+import { TIER_COST } from "./decay-curve";
+/** Default history budget when a caller doesn't supply one. */
+export declare const DEFAULT_HISTORY_BUDGET_TOKENS = 60000;
+/** Minimal compartment shape the renderer needs (subset of Compartment). */
+export interface DecayRenderCompartment {
+    startMessage: number;
+    endMessage: number;
+    title: string;
+    content: string;
+    startDate?: string | null;
+    endDate?: string | null;
+    p1?: string | null;
+    p2?: string | null;
+    p3?: string | null;
+    p4?: string | null;
+    importance?: number | null;
+    legacy?: number | null;
+}
+/**
+ * Render a single compartment at an explicit tier. Exposed for the m[1]
+ * "new compartments" block, which always renders newest compartments at P1
+ * (full fidelity — no decay applies to brand-new deltas).
+ */
+export declare function renderCompartmentAtTier(c: DecayRenderCompartment, tier: number): string;
+/**
+ * Compute the rendered tier for each compartment, given budget pressure derived
+ * once from the whole set. `compartments` are in chronological order (oldest
+ * first); the decay curve indexes from newest (1 = newest).
+ */
+/** Panel read-only reuse (plan 11 P2c): export the exact per-pass tier picker. */
+export declare function computeTiers(compartments: DecayRenderCompartment[], historyBudgetTokens: number): number[];
+/**
+ * Render the decayed compartment history block. Optionally prefixes a memory
+ * block. Never renders session facts (v2 faithful). Returns the joined body
+ * (no <session-history> wrapper — callers add their own framing).
+ */
+export declare function renderDecayedCompartments(args: {
+    compartments: DecayRenderCompartment[];
+    /** The caller converts the provider-token history budget to local tokens before rendering. */
+    historyBudgetTokens: number;
+}): string;
+/**
+ * Extract a top-level m[0] block slice (e.g. "session-history",
+ * "project-memory") for budget measurement and token attribution. Returns the
+ * full `<tag>…</tag>` slice or null. `tag` must be a literal block name (the
+ * caller controls it), so the constructed RegExp is safe.
+ *
+ * Shared so the materialize tightening loop measures ONLY the session-history
+ * slice against the history budget (not the whole m[0], which also carries
+ * project-memory — which has its own budget),
+ * and so the sidebar/status token attribution reads the same slices both
+ * harnesses actually render.
+ */
+export declare function extractM0Block(m0Text: string, tag: string): string | null;
+export { TIER_COST };
+//# sourceMappingURL=decay-render.d.ts.map

package/dist/hooks/magic-context/decay-render.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"decay-render.d.ts","sourceRoot":"","sources":["../../../src/hooks/magic-context/decay-render.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AAGH,OAAO,EAAuC,SAAS,EAAa,MAAM,eAAe,CAAC;AAG1F,+DAA+D;AAC/D,eAAO,MAAM,6BAA6B,QAAS,CAAC;AAEpD,4EAA4E;AAC5E,MAAM,WAAW,sBAAsB;IACnC,YAAY,EAAE,MAAM,CAAC;IACrB,UAAU,EAAE,MAAM,CAAC;IACnB,KAAK,EAAE,MAAM,CAAC;IACd,OAAO,EAAE,MAAM,CAAC;IAChB,SAAS,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAC1B,OAAO,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IACxB,EAAE,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IACnB,EAAE,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IACnB,EAAE,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IACnB,EAAE,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IACnB,UAAU,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAC3B,MAAM,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;CAC1B;AAyED;;;;GAIG;AACH,wBAAgB,uBAAuB,CAAC,CAAC,EAAE,sBAAsB,EAAE,IAAI,EAAE,MAAM,GAAG,MAAM,CAEvF;AAsBD;;;;GAIG;AACH,kFAAkF;AAClF,wBAAgB,YAAY,CACxB,YAAY,EAAE,sBAAsB,EAAE,EACtC,mBAAmB,EAAE,MAAM,GAC5B,MAAM,EAAE,CA8BV;AAED;;;;GAIG;AACH,wBAAgB,yBAAyB,CAAC,IAAI,EAAE;IAC5C,YAAY,EAAE,sBAAsB,EAAE,CAAC;IACvC,8FAA8F;IAC9F,mBAAmB,EAAE,MAAM,CAAC;CAC/B,GAAG,MAAM,CAyET;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,cAAc,CAAC,MAAM,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAGzE;AAED,OAAO,EAAE,SAAS,EAAE,CAAC"}

package/dist/hooks/magic-context/decision-calibration.d.ts

@@ -0,0 +1,24 @@
+import { type ModelCalibration } from "./tokenizer-calibration";
+/** Immutable static ratios; session usage samples never change this decision policy. */
+export interface DecisionCalibration extends Readonly<ModelCalibration> {
+    readonly modelKey: string;
+    readonly revision: string;
+    readonly matchedPrefix?: string;
+    readonly seeded: boolean;
+    readonly source: "seed" | "family-fallback" | "model-id";
+}
+export declare function resolveDecisionCalibration(providerId: string | undefined, modelId: string | undefined): DecisionCalibration;
+export interface LocalMass {
+    system?: number;
+    tools?: number;
+    prose?: number;
+}
+/** Accumulate fractional provider mass, then ceil once at the decision boundary. */
+export declare function providerMass(raw: LocalMass, seed: DecisionCalibration, fit?: boolean): number;
+/** Available real-token budgets round down so rendered local mass cannot overspend them. */
+export declare function localBudget(providerTokens: number, ratio: number): number;
+/** Split provider/model at the first slash, retaining any further slashes in the model name. */
+export declare function calibrationForModelKey(modelKey: string | null | undefined): DecisionCalibration;
+/** Convert at history materialization, not in cache markers: calibration must not trigger a fold. */
+export declare function historyLocalBudget(providerTokens: number, modelKey: string | null | undefined): number;
+//# sourceMappingURL=decision-calibration.d.ts.map

package/dist/hooks/magic-context/decision-calibration.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"decision-calibration.d.ts","sourceRoot":"","sources":["../../../src/hooks/magic-context/decision-calibration.ts"],"names":[],"mappings":"AAAA,OAAO,EAGH,KAAK,gBAAgB,EAGxB,MAAM,yBAAyB,CAAC;AAEjC,wFAAwF;AACxF,MAAM,WAAW,mBAAoB,SAAQ,QAAQ,CAAC,gBAAgB,CAAC;IACnE,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,aAAa,CAAC,EAAE,MAAM,CAAC;IAChC,QAAQ,CAAC,MAAM,EAAE,OAAO,CAAC;IACzB,QAAQ,CAAC,MAAM,EAAE,MAAM,GAAG,iBAAiB,GAAG,UAAU,CAAC;CAC5D;AAED,wBAAgB,0BAA0B,CACtC,UAAU,EAAE,MAAM,GAAG,SAAS,EAC9B,OAAO,EAAE,MAAM,GAAG,SAAS,GAC5B,mBAAmB,CAerB;AAED,MAAM,WAAW,SAAS;IACtB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,KAAK,CAAC,EAAE,MAAM,CAAC;CAClB;AAED,oFAAoF;AACpF,wBAAgB,YAAY,CAAC,GAAG,EAAE,SAAS,EAAE,IAAI,EAAE,mBAAmB,EAAE,GAAG,UAAQ,GAAG,MAAM,CAe3F;AAED,4FAA4F;AAC5F,wBAAgB,WAAW,CAAC,cAAc,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,MAAM,CASzE;AAED,gGAAgG;AAChG,wBAAgB,sBAAsB,CAAC,QAAQ,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,GAAG,mBAAmB,CAK/F;AAED,qGAAqG;AACrG,wBAAgB,kBAAkB,CAC9B,cAAc,EAAE,MAAM,EACtB,QAAQ,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,GACpC,MAAM,CAIR"}

package/dist/hooks/magic-context/degraded-pass-refusal.d.ts

@@ -0,0 +1,35 @@
+/**
+ * A transform pass failed at a stage whose output the request depends on: the
+ * session's saved drops, truncations or history cut could not be applied, or
+ * the pass would have returned the host's raw messages. Serving that pass can
+ * send a request several times larger than the previous one, so the pass stops
+ * instead. The messages wrapper replays the last good request when it can and
+ * otherwise refuses the turn with this message.
+ */
+export declare class DegradedPassRefusalError extends Error {
+    /** The stage that failed, by the name the pass records for it (e.g. "tagging-persistence-failure"). */
+    readonly site: string;
+    readonly code = "DEGRADED_PASS_REFUSAL";
+    readonly recoverable = true;
+    readonly estimatedTokens: number | undefined;
+    readonly contextLimitTokens: number | undefined;
+    constructor(
+    /** The stage that failed, by the name the pass records for it (e.g. "tagging-persistence-failure"). */
+    site: string, options?: {
+        cause?: unknown;
+        /** Set when the refusal comes from the served-request size guard. */
+        estimatedTokens?: number;
+        contextLimitTokens?: number;
+    });
+}
+/**
+ * The error a pass throws when a stage it cannot serve without has failed.
+ *
+ * A SQLite busy or locked error is rethrown unchanged: the messages wrapper
+ * already owns that case (replay the last good request, otherwise the
+ * storage-busy refusal and its host notice). Any other error becomes a
+ * {@link DegradedPassRefusalError}, which the wrapper treats the same way
+ * except for the message shown to the user.
+ */
+export declare function degradedPassError(site: string, error: unknown): Error;
+//# sourceMappingURL=degraded-pass-refusal.d.ts.map

package/dist/hooks/magic-context/degraded-pass-refusal.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"degraded-pass-refusal.d.ts","sourceRoot":"","sources":["../../../src/hooks/magic-context/degraded-pass-refusal.ts"],"names":[],"mappings":"AAGA;;;;;;;GAOG;AACH,qBAAa,wBAAyB,SAAQ,KAAK;IAO3C,uGAAuG;IACvG,QAAQ,CAAC,IAAI,EAAE,MAAM;IAPzB,QAAQ,CAAC,IAAI,2BAA2B;IACxC,QAAQ,CAAC,WAAW,QAAQ;IAC5B,QAAQ,CAAC,eAAe,EAAE,MAAM,GAAG,SAAS,CAAC;IAC7C,QAAQ,CAAC,kBAAkB,EAAE,MAAM,GAAG,SAAS,CAAC;;IAG5C,uGAAuG;IAC9F,IAAI,EAAE,MAAM,EACrB,OAAO,CAAC,EAAE;QACN,KAAK,CAAC,EAAE,OAAO,CAAC;QAChB,qEAAqE;QACrE,eAAe,CAAC,EAAE,MAAM,CAAC;QACzB,kBAAkB,CAAC,EAAE,MAAM,CAAC;KAC/B;CASR;AAED;;;;;;;;GAQG;AACH,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,GAAG,KAAK,CAKrE"}

package/dist/hooks/magic-context/derive-budgets.d.ts

@@ -0,0 +1,60 @@
+/**
+ * Budget derivation
+ *
+ * Two scaling bases, two clamps. Replaces the old static
+ * `compartment_token_budget` setting which tried to serve both roles
+ * and scaled with neither model.
+ *
+ *   - triggerBudget: scales with (main model × executeThreshold).
+ *     Drives size-based historian triggers (`tail_size`, `commit_clusters`).
+ *     "How big can the uncompartmentalized tail get before we force
+ *     historian to run." This is anchored to the MAIN model's usable
+ *     working space, not its total context.
+ *
+ *   - historianChunkTokens: scales with the HISTORIAN model's context.
+ *     The raw-history window historian processes per call. Different
+ *     scaling basis because historian is a single-shot summarizer bound
+ *     by its own context, not the main session's pressure math.
+ */
+/**
+ * Budget basis for size-based historian triggers (tail_size, commit_clusters).
+ * Anchored to the MAIN model's usable working space, not its total context.
+ *
+ * @param mainContextLimit Main session model's context window (tokens).
+ * @param executeThresholdPercentage The effective execute threshold (0-100).
+ */
+export declare function deriveTriggerBudget(mainContextLimit: number, executeThresholdPercentage: number): number;
+/**
+ * Raw-history chunk budget for historian's own context window.
+ * Historian formats tool calls as compact `TC:` summaries and drops tool results,
+ * so a 50K-token chunk typically represents far more raw messages than its token
+ * count implies. The max is tuned around that compression.
+ *
+ * @param historianContextLimit Historian model's context window (tokens).
+ */
+export declare function deriveHistorianChunkTokens(historianContextLimit: number): number;
+/**
+ * Resolve the historian model's context limit for chunk budget sizing.
+ *
+ * Behavior:
+ *   - If `historianModelOverride` is a full `provider/model-id` → use that model's
+ *     context directly. This honors explicit user intent.
+ *   - If the override is set but lacks `/` (e.g. `"llama3-32k"`) → warn and use
+ *     the conservative default, since we can't look up a model without a
+ *     provider and silently guessing would produce an incorrect chunk size.
+ *   - If no override (or the model is unknown to models.dev / opencode.json
+ *     custom providers) → 128K conservative default.
+ *
+ * Context limits are resolved through `getSdkContextLimit`, which reads
+ * OpenCode's SDK-resolved provider config (models.dev + snapshot + opencode.json
+ * overrides + auth-plugin caps), bounded to a sane range.
+ */
+export declare function resolveKnownHistorianContextLimit(historianModelOverride?: string): number | undefined;
+export declare function resolveHistorianProducerLimits(modelKey?: string): {
+    context?: number;
+    input?: number;
+};
+export declare function resolveHistorianContextLimit(historianModelOverride?: string): number;
+/** Formatted historian source mixes prose and compact tool records, so use the larger class seed. */
+export declare function producerSourceLocalBudget(providerTokens: number, modelKey: string | undefined): number;
+//# sourceMappingURL=derive-budgets.d.ts.map

package/dist/hooks/magic-context/derive-budgets.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"derive-budgets.d.ts","sourceRoot":"","sources":["../../../src/hooks/magic-context/derive-budgets.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAwBH;;;;;;GAMG;AACH,wBAAgB,mBAAmB,CAC/B,gBAAgB,EAAE,MAAM,EACxB,0BAA0B,EAAE,MAAM,GACnC,MAAM,CAYR;AAED;;;;;;;GAOG;AACH,wBAAgB,0BAA0B,CAAC,qBAAqB,EAAE,MAAM,GAAG,MAAM,CAMhF;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,iCAAiC,CAC7C,sBAAsB,CAAC,EAAE,MAAM,GAChC,MAAM,GAAG,SAAS,CASpB;AAED,wBAAgB,8BAA8B,CAAC,QAAQ,CAAC,EAAE,MAAM,GAAG;IAC/D,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,KAAK,CAAC,EAAE,MAAM,CAAC;CAClB,CAeA;AAED,wBAAgB,4BAA4B,CAAC,sBAAsB,CAAC,EAAE,MAAM,GAAG,MAAM,CAkBpF;AAED,qGAAqG;AACrG,wBAAgB,yBAAyB,CACrC,cAAc,EAAE,MAAM,EACtB,QAAQ,EAAE,MAAM,GAAG,SAAS,GAC7B,MAAM,CAIR"}

package/dist/hooks/magic-context/drop-stale-reduce-calls.d.ts

@@ -0,0 +1,39 @@
+import type { MessageLike } from "./tag-messages";
+export declare function isReduceToolPart(part: unknown): boolean;
+export interface StaleReduceStripResult {
+    /** True if any mmc_reduce part was sentinelized this pass. */
+    didDrop: boolean;
+    /** Message ids newly detected as aged this pass (only when detect=true). */
+    newlyStrippedIds: string[];
+}
+/**
+ * Sentinel-strip aged `mmc_reduce` tool parts using a FROZEN replay watermark.
+ *
+ * The cache-stability contract: a defer pass must replay byte-identical to the
+ * prior pass. An earlier version recomputed eligibility from the live
+ * `messages.length - protectedCount` boundary on every pass — but that boundary
+ * MOVES as the conversation grows, so a defer pass with tail growth would newly
+ * strip an older mmc_reduce call mid-prefix (for Anthropic the empty sentinel is
+ * filtered before the wire and the dropped tool_result lets the SDK merge
+ * adjacent assistants → the message vanishes + the array shifts → the cached
+ * prefix busts). That is exactly the bug this design removes.
+ *
+ * Instead, eligibility is an id-keyed frozen set:
+ * - REPLAY (every pass): strip mmc_reduce parts in any message whose `info.id`
+ *   is in `frozenIds`. Growth-invariant and compaction-safe (a missing id is a
+ *   no-op). This is what makes defer passes byte-identical.
+ * - DETECT (cache-busting passes only, `detect=true`): additionally scan the
+ *   pre-protected region for mmc_reduce calls not yet frozen, strip them, and
+ *   return their ids in `newlyStrippedIds` so the caller can advance the
+ *   persisted watermark. Detection happens only on passes where the wire is
+ *   already allowed to change, so it never busts a defer pass.
+ *
+ * Messages without a stable `info.id` are never newly detected (they cannot be
+ * frozen for deterministic replay), so they are left intact rather than stripped
+ * inconsistently.
+ */
+export declare function dropStaleReduceCalls(messages: MessageLike[], frozenIds: Set<string>, options?: {
+    detect?: boolean;
+    protectedCount?: number;
+}): StaleReduceStripResult;
+//# sourceMappingURL=drop-stale-reduce-calls.d.ts.map