@retaw106/mmc-oc 0.0.0-stage → 1.2.2

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

@@ -0,0 +1 @@
+{"version":3,"file":"drop-stale-reduce-calls.d.ts","sourceRoot":"","sources":["../../../src/hooks/magic-context/drop-stale-reduce-calls.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAC;AAIlD,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,OAAO,GAAG,OAAO,CAoBvD;AA+CD,MAAM,WAAW,sBAAsB;IACnC,8DAA8D;IAC9D,OAAO,EAAE,OAAO,CAAC;IACjB,4EAA4E;IAC5E,gBAAgB,EAAE,MAAM,EAAE,CAAC;CAC9B;AAED;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,wBAAgB,oBAAoB,CAChC,QAAQ,EAAE,WAAW,EAAE,EACvB,SAAS,EAAE,GAAG,CAAC,MAAM,CAAC,EACtB,OAAO,GAAE;IAAE,MAAM,CAAC,EAAE,OAAO,CAAC;IAAC,cAAc,CAAC,EAAE,MAAM,CAAA;CAAO,GAC5D,sBAAsB,CAiCxB"}

package/dist/hooks/magic-context/dropped-input-guard.d.ts

@@ -0,0 +1,55 @@
+export declare function droppedInputMarker(tagId: number): {
+    dropped: string;
+};
+export declare function containsDroppedInputPlaceholder(value: unknown): boolean;
+export interface ToolParameterNames {
+    required: string[];
+    optional: string[];
+}
+/**
+ * Read a tool's parameter names from its schema. Pi and OpenCode 2 hand over
+ * JSON Schema (`properties` + `required`); the OpenCode 1 `tool.definition`
+ * hook hands over the tool's zod object. Anything else yields undefined so the
+ * refusal never invents names it could not see.
+ */
+export declare function toolParameterNames(schema: unknown): ToolParameterNames | undefined;
+export declare function recordToolParameters(toolName: string, schema: unknown): void;
+export interface DroppedInputRefusal {
+    toolName?: string;
+    input: unknown;
+    /** The tool's schema when the caller can see it; names are otherwise looked up by tool name. */
+    parameters?: unknown;
+    /** How many calls in a row, including this one, carried placeholder arguments. */
+    consecutive: number;
+}
+/**
+ * The tool-result text a refused call gets back. The model wrote the
+ * placeholder itself (usually by copying the dropped-call rendering from its
+ * history), so the text says exactly that, shows what was received, and names
+ * what to send instead. mmc_expand is only for recovering an earlier call's
+ * arguments, never a prerequisite for a fresh call.
+ */
+export declare function droppedInputRefusalMessage(refusal: DroppedInputRefusal): string;
+export interface DroppedInputCall {
+    sessionID?: string;
+    toolName?: string;
+    input: unknown;
+}
+export interface DroppedInputGuardOptions {
+    /** Look up a tool's live schema by name (Pi exposes every tool's parameters). */
+    parametersFor?: (toolName: string) => unknown;
+}
+/**
+ * Stateful guard for one plugin instance. Detection is purely content-based;
+ * the state is only the per-session count of consecutive refusals, which a
+ * call that passes the guard resets.
+ */
+export declare function createDroppedInputGuard(options?: DroppedInputGuardOptions): {
+    /** Returns the refusal text for a placeholder call, or undefined when the call may run. */
+    check(call: DroppedInputCall): string | undefined;
+};
+export type DroppedInputGuard = ReturnType<typeof createDroppedInputGuard>;
+/** Throw the refusal for a placeholder call; OpenCode surfaces the error as the tool result. */
+export declare function assertExecutableToolInput(guard: DroppedInputGuard, call: DroppedInputCall): void;
+export declare function createDroppedInputToolExecuteBeforeHook(): (input: unknown, output: unknown) => Promise<void>;
+//# sourceMappingURL=dropped-input-guard.d.ts.map

package/dist/hooks/magic-context/dropped-input-guard.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dropped-input-guard.d.ts","sourceRoot":"","sources":["../../../src/hooks/magic-context/dropped-input-guard.ts"],"names":[],"mappings":"AAwBA,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,MAAM,GAAG;IAAE,OAAO,EAAE,MAAM,CAAA;CAAE,CAErE;AAED,wBAAgB,+BAA+B,CAAC,KAAK,EAAE,OAAO,GAAG,OAAO,CAavE;AAED,MAAM,WAAW,kBAAkB;IAC/B,QAAQ,EAAE,MAAM,EAAE,CAAC;IACnB,QAAQ,EAAE,MAAM,EAAE,CAAC;CACtB;AAoBD;;;;;GAKG;AACH,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,OAAO,GAAG,kBAAkB,GAAG,SAAS,CA+BlF;AAOD,wBAAgB,oBAAoB,CAAC,QAAQ,EAAE,MAAM,EAAE,MAAM,EAAE,OAAO,GAAG,IAAI,CAI5E;AAuCD,MAAM,WAAW,mBAAmB;IAChC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,KAAK,EAAE,OAAO,CAAC;IACf,gGAAgG;IAChG,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,kFAAkF;IAClF,WAAW,EAAE,MAAM,CAAC;CACvB;AAED;;;;;;GAMG;AACH,wBAAgB,0BAA0B,CAAC,OAAO,EAAE,mBAAmB,GAAG,MAAM,CAiB/E;AAED,MAAM,WAAW,gBAAgB;IAC7B,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,KAAK,EAAE,OAAO,CAAC;CAClB;AAED,MAAM,WAAW,wBAAwB;IACrC,iFAAiF;IACjF,aAAa,CAAC,EAAE,CAAC,QAAQ,EAAE,MAAM,KAAK,OAAO,CAAC;CACjD;AAED;;;;GAIG;AACH,wBAAgB,uBAAuB,CAAC,OAAO,GAAE,wBAA6B;IAItE,2FAA2F;gBAC/E,gBAAgB,GAAG,MAAM,GAAG,SAAS;EA6BxD;AAED,MAAM,MAAM,iBAAiB,GAAG,UAAU,CAAC,OAAO,uBAAuB,CAAC,CAAC;AAE3E,gGAAgG;AAChG,wBAAgB,yBAAyB,CAAC,KAAK,EAAE,iBAAiB,EAAE,IAAI,EAAE,gBAAgB,GAAG,IAAI,CAGhG;AAED,wBAAgB,uCAAuC,KAErC,OAAO,OAAO,EAAE,QAAQ,OAAO,KAAG,OAAO,CAAC,IAAI,CAAC,CAShE"}

package/dist/hooks/magic-context/dropped-token-estimate.d.ts

@@ -0,0 +1,20 @@
+import type { ContextDatabase } from "../../features/magic-context/storage";
+export type DroppedTokenReduction = {
+    tagNumber: number;
+    mode: "full" | "truncated" | "edit_marker";
+} | {
+    tagNumber: number;
+    mode: "partial";
+    removedCharacters: number;
+};
+/**
+ * Estimate the tokens removed by reductions first applied during this pass.
+ * Full removals use every persisted token component carried by the tag row.
+ * Tool skeletons retain invocation structure, so they count only the persisted
+ * output token_count that the skeleton removes. Partial text rewrites cannot
+ * derive their removed share from the full persisted count; only their observed
+ * removed characters use the same 3.5-characters-per-token fallback as the
+ * tokenizer's failure path. The full message array is never serialized here.
+ */
+export declare function estimateDroppedTokensFromTagReductions(db: ContextDatabase, sessionId: string, reductions: readonly DroppedTokenReduction[]): number;
+//# sourceMappingURL=dropped-token-estimate.d.ts.map

package/dist/hooks/magic-context/dropped-token-estimate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dropped-token-estimate.d.ts","sourceRoot":"","sources":["../../../src/hooks/magic-context/dropped-token-estimate.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,sCAAsC,CAAC;AAK5E,MAAM,MAAM,qBAAqB,GAC3B;IACI,SAAS,EAAE,MAAM,CAAC;IAClB,IAAI,EAAE,MAAM,GAAG,WAAW,GAAG,aAAa,CAAC;CAC9C,GACD;IACI,SAAS,EAAE,MAAM,CAAC;IAClB,IAAI,EAAE,SAAS,CAAC;IAChB,iBAAiB,EAAE,MAAM,CAAC;CAC7B,CAAC;AAmDR;;;;;;;;GAQG;AACH,wBAAgB,sCAAsC,CAClD,EAAE,EAAE,eAAe,EACnB,SAAS,EAAE,MAAM,EACjB,UAAU,EAAE,SAAS,qBAAqB,EAAE,GAC7C,MAAM,CA6CR"}

package/dist/hooks/magic-context/edit-marker.d.ts

@@ -0,0 +1,11 @@
+/** Region-hint length: enough to identify the edited section, cheap to keep. */
+export declare const EDIT_REGION_HINT_LEN = 40;
+/** True for the tools whose superseded older calls we compress. */
+export declare function isEditTool(name: string | null | undefined): boolean;
+/**
+ * Mutate a tool input object in place into its edit-marker form: preserve
+ * path-like keys verbatim, clamp the diff keys to a region-hint prefix, leave
+ * other (small) keys untouched. Idempotent.
+ */
+export declare function applyEditMarkerToInput(input: Record<string, unknown>): void;
+//# sourceMappingURL=edit-marker.d.ts.map

package/dist/hooks/magic-context/edit-marker.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"edit-marker.d.ts","sourceRoot":"","sources":["../../../src/hooks/magic-context/edit-marker.ts"],"names":[],"mappings":"AAqBA,gFAAgF;AAChF,eAAO,MAAM,oBAAoB,KAAK,CAAC;AAoBvC,mEAAmE;AACnE,wBAAgB,UAAU,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,GAAG,OAAO,CAEnE;AAED;;;;GAIG;AACH,wBAAgB,sBAAsB,CAAC,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI,CAW3E"}

package/dist/hooks/magic-context/emergency-drop.d.ts

@@ -0,0 +1,112 @@
+import type { TagTarget } from "./tag-messages";
+/** Reclaim target = fixedFloor + TARGET_FRACTION × (ceiling − fixedFloor). */
+export declare const TARGET_FRACTION = 0.3;
+/** Keep the newest `ceil(RESERVE × tierCount)` of T1/T2 as continuation context. */
+export declare const TIER_RECENCY_RESERVE = 0.2;
+/**
+ * Don't bust the cache for a trivial reclaim. If the computed reclaim is at or
+ * below this, the pass is a no-op (combined with the watermark, this prevents
+ * force-band-to-94.9% oscillation).
+ */
+export declare const EMERGENCY_REARM_MIN_TOKENS = 2000;
+/**
+ * The selected candidates must together reclaim at least this many tokens, or
+ * the pass is skipped. The gap check above only proves there is something to
+ * close; it says nothing about what the candidates can actually win back. One
+ * live session spent an hour at 100% context dropping one fresh tool result
+ * per pass, 28 to 149 tokens each against a ~9,200-token gap, rewriting a
+ * cached prefix of ~300K tokens every time.
+ */
+export declare const EMERGENCY_MIN_ACHIEVABLE_RECLAIM_TOKENS = 2000;
+export type Tier = 1 | 2 | 3;
+/**
+ * Classify a tool into its drop tier. T1 (keep longest) = navigation/structure
+ * the agent re-uses; T2 (medium) = edit-class continuation context; T3 (drop
+ * first) = everything else (the default — bash, mmc_reduce, inspect, web, …).
+ */
+export declare function resolveToolTier(toolName: string | null): Tier;
+/** Minimal tag shape the planner needs (subset of TagEntry, harness-agnostic). */
+export interface EmergencyDropTag {
+    tagNumber: number;
+    type: "message" | "tool" | "file";
+    status: "active" | "dropped" | "compacted";
+    toolName: string | null;
+    byteSize: number;
+    /** Tool-arg bytes — `drop()` removes the invocation too, so these reclaim. */
+    inputByteSize: number;
+    reasoningByteSize: number;
+    /** Provider-token observations from the current representation, never persisted raw tag counts. */
+    servedTokens?: number;
+    reclaimableTokens?: number;
+}
+export interface EmergencyDropPlan {
+    /** Whether the caller should perform any drop this pass. */
+    shouldDrop: boolean;
+    /** Tool tag numbers to drop, in eviction order (T3→T2→T1, oldest-first). */
+    tagNumbers: number[];
+    /** Reclaim target in tokens (for logging). */
+    reclaimTokens: number;
+    /** Human-readable reason (no-op explanation or drop summary), for logs. */
+    reason: string;
+}
+export declare function estimateEmergencyDropReclaimTokens(tag: EmergencyDropTag): number;
+/**
+ * Plan a tiered target-headroom emergency drop. Pure: returns the ordered set of
+ * tool tag numbers to drop, a token target, and a reason; the caller applies them.
+ *
+ * fixedFloor is estimated as current provider input minus measured active-tail mass.
+ * Content with no observable token count remains in that fixed portion. This is
+ * conservative reclaim planning, not proof that every remaining token is irreducible.
+ *
+ * The two tag sets serve DIFFERENT contracts and must not be conflated:
+ * - `floorTags`: the ENTIRE active live-window tag set (all types, including
+ *   non-droppable tool tags). Their served mass determines the estimated fixed floor. Passing a narrower set (e.g.
+ *   tool-only) folds real conversation/reasoning tail into the "floor",
+ *   raising the target and systematically under-evicting at the derived force band.
+ * - `tags`: the evictable candidates — active tool tags whose drop target
+ *   would actually reclaim bytes (caller pre-filters on `canDrop()` so no
+ *   phantom tag is counted as reclaimed).
+ */
+export declare function planEmergencyDrop(input: {
+    /** Evictable candidates: active tool tags with a working drop target. */
+    tags: readonly EmergencyDropTag[];
+    /**
+     * FULL active live-window tag set (all types) — floor accounting only.
+     * See the fixedFloor contract above.
+     */
+    floorTags: readonly EmergencyDropTag[];
+    maxTag: number;
+    /**
+     * Union projection form: exact tag-number cutoff directly.
+     * Coordinate space: tag-number space (number | null).
+     * Empty-window behavior: branches on absent cutoff (null), applying no tag-number threshold.
+     */
+    protectedCutoff: number | null;
+    /** Provider-proven or estimated pressure; at 95% only open arcs and exemplars survive. */
+    usagePercentage?: number;
+    currentTotalInputTokens: number;
+    /** ceiling = contextLimit × executeThreshold%. */
+    ceilingTokens: number;
+    /**
+     * `last_emergency_input_sample` is retained as the pressure-episode latch:
+     * zero means armed, non-zero means this force-band episode already had its
+     * originating batch. The caller rearms on pressure exit or an independent
+     * bust. There is deliberately no tag-number watermark because a scalar
+     * cursor would exclude still-active lower-numbered tags after tiered drops.
+     */
+    priorInputSample: number;
+    /** True while the persisted pressure-episode latch is non-zero. */
+    hasPriorDrop: boolean;
+    /**
+     * True when another mutation already rewrites the cached prefix on this
+     * pass. The selection then rides that rewrite for free, so the minimum
+     * achievable reclaim does not apply.
+     */
+    passAlreadyPriced?: boolean;
+}): EmergencyDropPlan;
+/** Count current content and the planned replacement without mutating either cached representation. */
+export declare function measureEmergencyTag<T extends EmergencyDropTag>(tag: T, target: TagTarget | undefined, calibration: {
+    toolsRatio: number;
+    proseRatio: number;
+}, skeleton: boolean): T & EmergencyDropTag;
+//# sourceMappingURL=emergency-drop.d.ts.map

package/dist/hooks/magic-context/emergency-drop.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"emergency-drop.d.ts","sourceRoot":"","sources":["../../../src/hooks/magic-context/emergency-drop.ts"],"names":[],"mappings":"AAsBA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAEhD,8EAA8E;AAC9E,eAAO,MAAM,eAAe,MAAM,CAAC;AAEnC,oFAAoF;AACpF,eAAO,MAAM,oBAAoB,MAAM,CAAC;AAExC;;;;GAIG;AACH,eAAO,MAAM,0BAA0B,OAAO,CAAC;AAE/C;;;;;;;GAOG;AACH,eAAO,MAAM,uCAAuC,OAA6B,CAAC;AAElF,MAAM,MAAM,IAAI,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;AAiB7B;;;;GAIG;AACH,wBAAgB,eAAe,CAAC,QAAQ,EAAE,MAAM,GAAG,IAAI,GAAG,IAAI,CAK7D;AAED,kFAAkF;AAClF,MAAM,WAAW,gBAAgB;IAC7B,SAAS,EAAE,MAAM,CAAC;IAClB,IAAI,EAAE,SAAS,GAAG,MAAM,GAAG,MAAM,CAAC;IAClC,MAAM,EAAE,QAAQ,GAAG,SAAS,GAAG,WAAW,CAAC;IAC3C,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAC;IACxB,QAAQ,EAAE,MAAM,CAAC;IACjB,8EAA8E;IAC9E,aAAa,EAAE,MAAM,CAAC;IACtB,iBAAiB,EAAE,MAAM,CAAC;IAC1B,mGAAmG;IACnG,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,iBAAiB,CAAC,EAAE,MAAM,CAAC;CAC9B;AAaD,MAAM,WAAW,iBAAiB;IAC9B,4DAA4D;IAC5D,UAAU,EAAE,OAAO,CAAC;IACpB,4EAA4E;IAC5E,UAAU,EAAE,MAAM,EAAE,CAAC;IACrB,8CAA8C;IAC9C,aAAa,EAAE,MAAM,CAAC;IACtB,2EAA2E;IAC3E,MAAM,EAAE,MAAM,CAAC;CAClB;AAED,wBAAgB,kCAAkC,CAAC,GAAG,EAAE,gBAAgB,GAAG,MAAM,CAIhF;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,iBAAiB,CAAC,KAAK,EAAE;IACrC,yEAAyE;IACzE,IAAI,EAAE,SAAS,gBAAgB,EAAE,CAAC;IAClC;;;OAGG;IACH,SAAS,EAAE,SAAS,gBAAgB,EAAE,CAAC;IACvC,MAAM,EAAE,MAAM,CAAC;IACf;;;;OAIG;IACH,eAAe,EAAE,MAAM,GAAG,IAAI,CAAC;IAC/B,0FAA0F;IAC1F,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,uBAAuB,EAAE,MAAM,CAAC;IAChC,kDAAkD;IAClD,aAAa,EAAE,MAAM,CAAC;IACtB;;;;;;OAMG;IACH,gBAAgB,EAAE,MAAM,CAAC;IACzB,mEAAmE;IACnE,YAAY,EAAE,OAAO,CAAC;IACtB;;;;OAIG;IACH,iBAAiB,CAAC,EAAE,OAAO,CAAC;CAC/B,GAAG,iBAAiB,CA+JpB;AAED,uGAAuG;AACvG,wBAAgB,mBAAmB,CAAC,CAAC,SAAS,gBAAgB,EAC1D,GAAG,EAAE,CAAC,EACN,MAAM,EAAE,SAAS,GAAG,SAAS,EAC7B,WAAW,EAAE;IAAE,UAAU,EAAE,MAAM,CAAC;IAAC,UAAU,EAAE,MAAM,CAAA;CAAE,EACvD,QAAQ,EAAE,OAAO,GAClB,CAAC,GAAG,gBAAgB,CAkBtB"}

package/dist/hooks/magic-context/emergency-fail-closed.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Calm user-facing line for fail-closed refusals caused by the engine being
+ * temporarily unreachable. States what happened and what to do; deliberately
+ * carries no token counts or internals — the numbers belong to the log lines
+ * that accompany the throw, not the primary message a user reads.
+ */
+export declare const ENGINE_RECONNECTING_USER_MESSAGE = "Magic Context's engine is reconnecting. Send your message again in a few seconds.";
+export declare class EmergencyFailClosedError extends Error {
+    readonly code = "EMERGENCY_FAIL_CLOSED";
+    constructor(message: string, options?: {
+        cause?: unknown;
+    });
+}
+//# sourceMappingURL=emergency-fail-closed.d.ts.map

package/dist/hooks/magic-context/emergency-fail-closed.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"emergency-fail-closed.d.ts","sourceRoot":"","sources":["../../../src/hooks/magic-context/emergency-fail-closed.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,eAAO,MAAM,gCAAgC,sFAC0C,CAAC;AAExF,qBAAa,wBAAyB,SAAQ,KAAK;IAC/C,QAAQ,CAAC,IAAI,2BAA2B;gBAE5B,OAAO,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE;QAAE,KAAK,CAAC,EAAE,OAAO,CAAA;KAAE;CAI7D"}

package/dist/hooks/magic-context/empty-task-output.d.ts

@@ -0,0 +1,16 @@
+export declare const EMPTY_TASK_OUTPUT_SENTINEL = "<magic-context-empty-task-output>";
+/**
+ * Surface a completed native `task` tool result that returned no final text.
+ *
+ * A subagent can complete with an empty `<task_result>` when its provider
+ * emitted reasoning only (or context-fill truncation dropped the final output).
+ * OpenCode would otherwise hand the caller a silently-empty result, which is
+ * indistinguishable from a tool that legitimately returned nothing. Annotate
+ * such outputs with a diagnostic sentinel so the caller can tell the two apart.
+ *
+ * Only a completed native task with an empty result is touched; non-task tools,
+ * non-empty outputs, and non-completed task states are left unchanged. The
+ * mutation is done via `Reflect.set` so a frozen output object cannot throw.
+ */
+export declare function annotateEmptyTaskOutput(tool: string, output: unknown): void;
+//# sourceMappingURL=empty-task-output.d.ts.map

package/dist/hooks/magic-context/empty-task-output.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"empty-task-output.d.ts","sourceRoot":"","sources":["../../../src/hooks/magic-context/empty-task-output.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,0BAA0B,sCAAsC,CAAC;AAI9E;;;;;;;;;;;;GAYG;AACH,wBAAgB,uBAAuB,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,OAAO,GAAG,IAAI,CAY3E"}

package/dist/hooks/magic-context/event-payloads.d.ts

@@ -0,0 +1,73 @@
+export type MagicContextEventType = "session.created" | "session.error" | "message.updated" | "message.part.updated" | "message.removed" | "session.compacted" | "session.deleted";
+export type MagicContextEvent = {
+    type: MagicContextEventType;
+    properties?: unknown;
+};
+export interface SessionCreatedInfo {
+    id: string;
+    parentID: string;
+    directory?: string;
+    providerID?: string;
+    modelID?: string;
+    /**
+     * Session title set at create time. Magic Context's own hidden children
+     * (historian/dreamer) all use `magic-context-*`
+     * titles, so this is the signal used to fully exempt them from the
+     * transform + system-prompt injection pipeline.
+     */
+    title?: string;
+}
+export interface MessageUpdatedAssistantInfo {
+    role: "assistant";
+    finish?: string;
+    sessionID: string;
+    /** OpenCode assistant message id. Undefined only when the event payload
+     *  doesn't include one (older SDK versions or malformed events). */
+    messageID?: string;
+    parentID?: string;
+    completedAt?: number;
+    providerID?: string;
+    modelID?: string;
+    tokens?: {
+        input?: number;
+        cache?: {
+            read?: number;
+            write?: number;
+        };
+    };
+    /** Error attached to the assistant message, if any. OpenCode attaches
+     *  context-overflow errors here in addition to emitting session.error. */
+    error?: unknown;
+}
+export interface MessageUpdatedInfo {
+    role: "user" | "assistant" | string;
+    sessionID: string;
+    messageID?: string;
+    finish?: string;
+    completedAt?: number;
+}
+export interface SessionErrorInfo {
+    sessionID: string;
+    error: unknown;
+    providerID?: string;
+    modelID?: string;
+}
+export interface MessageRemovedInfo {
+    sessionID: string;
+    messageID: string;
+}
+export declare function getSessionProperties(properties: unknown): {
+    info?: unknown;
+    sessionID?: string;
+} | undefined;
+export declare function getSessionCreatedInfo(properties: unknown): SessionCreatedInfo | null;
+export declare function getMessageUpdatedAssistantInfo(properties: unknown): MessageUpdatedAssistantInfo | null;
+export declare function getMessageUpdatedInfo(properties: unknown): MessageUpdatedInfo | null;
+/**
+ * Extract `session.error` payloads without depending on a specific NamedError
+ * variant. OpenCode normally emits only `{ sessionID, error }`, while some
+ * provider errors also carry model identity at the top level or in `error.data`.
+ */
+export declare function getSessionErrorInfo(properties: unknown): SessionErrorInfo | null;
+export declare function getMessageRemovedInfo(properties: unknown): MessageRemovedInfo | null;
+//# sourceMappingURL=event-payloads.d.ts.map

package/dist/hooks/magic-context/event-payloads.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"event-payloads.d.ts","sourceRoot":"","sources":["../../../src/hooks/magic-context/event-payloads.ts"],"names":[],"mappings":"AAEA,MAAM,MAAM,qBAAqB,GAC3B,iBAAiB,GACjB,eAAe,GACf,iBAAiB,GACjB,sBAAsB,GACtB,iBAAiB,GACjB,mBAAmB,GACnB,iBAAiB,CAAC;AAExB,MAAM,MAAM,iBAAiB,GAAG;IAC5B,IAAI,EAAE,qBAAqB,CAAC;IAC5B,UAAU,CAAC,EAAE,OAAO,CAAC;CACxB,CAAC;AAEF,MAAM,WAAW,kBAAkB;IAC/B,EAAE,EAAE,MAAM,CAAC;IACX,QAAQ,EAAE,MAAM,CAAC;IACjB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB;;;;;OAKG;IACH,KAAK,CAAC,EAAE,MAAM,CAAC;CAClB;AAED,MAAM,WAAW,2BAA2B;IACxC,IAAI,EAAE,WAAW,CAAC;IAClB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,SAAS,EAAE,MAAM,CAAC;IAClB;wEACoE;IACpE,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,MAAM,CAAC,EAAE;QACL,KAAK,CAAC,EAAE,MAAM,CAAC;QACf,KAAK,CAAC,EAAE;YACJ,IAAI,CAAC,EAAE,MAAM,CAAC;YACd,KAAK,CAAC,EAAE,MAAM,CAAC;SAClB,CAAC;KACL,CAAC;IACF;8EAC0E;IAC1E,KAAK,CAAC,EAAE,OAAO,CAAC;CACnB;AAED,MAAM,WAAW,kBAAkB;IAC/B,IAAI,EAAE,MAAM,GAAG,WAAW,GAAG,MAAM,CAAC;IACpC,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,WAAW,CAAC,EAAE,MAAM,CAAC;CACxB;AAED,MAAM,WAAW,gBAAgB;IAC7B,SAAS,EAAE,MAAM,CAAC;IAClB,KAAK,EAAE,OAAO,CAAC;IACf,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,OAAO,CAAC,EAAE,MAAM,CAAC;CACpB;AAED,MAAM,WAAW,kBAAkB;IAC/B,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,MAAM,CAAC;CACrB;AAED,wBAAgB,oBAAoB,CAChC,UAAU,EAAE,OAAO,GACpB;IAAE,IAAI,CAAC,EAAE,OAAO,CAAC;IAAC,SAAS,CAAC,EAAE,MAAM,CAAA;CAAE,GAAG,SAAS,CAUpD;AAED,wBAAgB,qBAAqB,CAAC,UAAU,EAAE,OAAO,GAAG,kBAAkB,GAAG,IAAI,CAmBpF;AAED,wBAAgB,8BAA8B,CAC1C,UAAU,EAAE,OAAO,GACpB,2BAA2B,GAAG,IAAI,CAiCpC;AAED,wBAAgB,qBAAqB,CAAC,UAAU,EAAE,OAAO,GAAG,kBAAkB,GAAG,IAAI,CAmBpF;AAMD;;;;GAIG;AACH,wBAAgB,mBAAmB,CAAC,UAAU,EAAE,OAAO,GAAG,gBAAgB,GAAG,IAAI,CAiChF;AAED,wBAAgB,qBAAqB,CAAC,UAAU,EAAE,OAAO,GAAG,kBAAkB,GAAG,IAAI,CAapF"}

package/dist/hooks/magic-context/event-resolvers.d.ts

@@ -0,0 +1,114 @@
+import { type ContextDatabase } from "../../features/magic-context/storage";
+import { escalationBands, MAX_EXECUTE_THRESHOLD } from "../../shared/escalation-bands";
+export { escalationBands, MAX_EXECUTE_THRESHOLD };
+export declare const DEFAULT_CONTEXT_LIMIT = 200000;
+export declare function resolveContextWindowGeometry(providerID: string | undefined, modelID: string | undefined, ctx?: {
+    db?: ContextDatabase;
+    sessionID?: string;
+}): import("../../shared/window-geometry").WindowGeometryResult | undefined;
+type CacheTtlConfig = string | Record<string, string>;
+/**
+ * Resolve the effective context limit for a provider/model pair. By default
+ * this returns the output-reserved safe input budget. `reservation: "none"`
+ * preserves the same catalog, detected-limit, and fallback resolution while
+ * exposing the unreserved window for native-usage display metrics only.
+ */
+export declare function resolveContextLimit(providerID: string | undefined, modelID: string | undefined, ctx?: {
+    db?: ContextDatabase;
+    sessionID?: string;
+    reservation?: "default" | "none";
+}): number;
+/**
+ * Like resolveContextLimit, but returns a limit ONLY when it is TRUSTED for the
+ * current model, rather than the generic 200K `DEFAULT_CONTEXT_LIMIT`.
+ *
+ * Resolution precedence is:
+ *   1. models.dev or a user provider override.
+ *   2. A detected-overflow limit when it is smaller than the models.dev limit,
+ *      or whenever models.dev has no entry.
+ *   3. A sane persisted usage-reported limit when models.dev and overflow
+ *      detection are both unavailable, but only when its observed model key
+ *      matches the current model key.
+ *
+ * The history-budget resolver needs this distinction: deriving the decay budget
+ * from a bare 128K guess for an UNKNOWN model would shrink history below what
+ * the live-usage back-derivation would yield for a large-context model. So the
+ * budget resolver only trusts a real, detected, or model-matched usage-reported
+ * limit and otherwise falls back to live-usage. (resolveContextLimit itself must
+ * keep returning 128K for pressure math, which needs a positive denominator.)
+ */
+export declare function resolveTrustedContextLimit(providerID: string | undefined, modelID: string | undefined, ctx?: {
+    db?: ContextDatabase;
+    sessionID?: string;
+}): number | undefined;
+export declare function resolveCacheTtl(cacheTtl: CacheTtlConfig, modelKey: string | undefined): string;
+type ExecuteThresholdConfig = number | {
+    default: number;
+    [modelKey: string]: number;
+};
+type ExecuteThresholdTokensConfig = {
+    default?: number;
+    [modelKey: string]: number | undefined;
+} | undefined;
+export interface ExecuteThresholdOptions {
+    /** Optional tokens-based threshold config. When matched for the given modelKey,
+     *  overrides the percentage-based threshold. */
+    tokensConfig?: ExecuteThresholdTokensConfig;
+    /** Required when `tokensConfig` is provided — used to convert tokens → percentage
+     *  and to clamp values above 90% × context_limit. */
+    contextLimit?: number;
+    /** Session ID for warn logs when clamping. If absent, warns to global log. */
+    sessionId?: string;
+}
+export type ExecuteThresholdMode = "percentage" | "tokens";
+export interface ExecuteThresholdDetail {
+    /** Effective execute threshold as a percentage (0–90). Downstream math keys off this. */
+    percentage: number;
+    /** Which source was authoritative: tokens config (when matched + valid context) or percentage. */
+    mode: ExecuteThresholdMode;
+    /** When mode is "tokens", the absolute token value after clamping (≤ 90% × contextLimit). */
+    absoluteTokens?: number;
+    /** The config key that matched, if any (for display/debugging). `"default"` when default fallback. */
+    matchedKey?: string;
+    /**
+     * True when the user's configured value exceeded the safe cap and was reduced.
+     * Tokens mode: configured tokens > 90% × contextLimit. Percentage mode:
+     * configured percentage > MAX_EXECUTE_THRESHOLD (90). Display surfaces read this
+     * to tell the user their value was clamped instead of silently ignoring it (#241).
+     * Only present (true) when a clamp actually happened; absent otherwise.
+     */
+    clamped?: boolean;
+    /**
+     * The raw configured value before clamping — a token count in tokens mode, a
+     * percentage in percentage mode. Populated only alongside `clamped` so display
+     * surfaces can show the math (e.g. "190,000 > 90% of 128,000").
+     */
+    configuredValue?: number;
+}
+/**
+ * Single source of truth for execute-threshold resolution. Returns the effective
+ * percentage plus which config source was authoritative. Callers that only need
+ * the percentage can use `resolveExecuteThreshold` (thin wrapper below); callers
+ * that surface the mode to users (`/mmc-status`, TUI, RPC) must use this directly
+ * to avoid the "progressive lookup drift" bug where two call sites disagree on
+ * whether tokens mode is active.
+ */
+export declare function resolveExecuteThresholdDetail(config: ExecuteThresholdConfig, modelKey: string | undefined, fallback: number, options?: ExecuteThresholdOptions): ExecuteThresholdDetail;
+/**
+ * Backward-compatible wrapper around `resolveExecuteThresholdDetail`.
+ * Use the detail version when you also need the mode or absolute token value.
+ */
+export declare function resolveExecuteThreshold(config: ExecuteThresholdConfig, modelKey: string | undefined, fallback: number, options?: ExecuteThresholdOptions): number;
+export declare function resolveModelKey(providerID: string | undefined, modelID: string | undefined): string | undefined;
+export declare function resolveSessionId(properties: {
+    info?: unknown;
+    sessionID?: string;
+} | undefined): string | undefined;
+/**
+ * Identify the configured history fraction and selected execute threshold used
+ * to size history. Catalog refreshes and accepted-input measurements can change
+ * the available window without a user config edit, so they must not invalidate
+ * the cached m[0] prefix. Actual rendering still budgets against that live window.
+ */
+export declare function historyBudgetPolicyIdentity(historyBudgetPercentage: number | undefined, executeThresholdPercentage: ExecuteThresholdConfig | undefined, modelKey: string | undefined, executeThresholdTokens?: ExecuteThresholdTokensConfig): string;
+//# sourceMappingURL=event-resolvers.d.ts.map

package/dist/hooks/magic-context/event-resolvers.d.ts.map

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

package/dist/hooks/magic-context/execute-flush.d.ts

@@ -0,0 +1,3 @@
+import type { Database } from "../../shared/sqlite";
+export declare function executeFlush(db: Database, sessionId: string): string;
+//# sourceMappingURL=execute-flush.d.ts.map

package/dist/hooks/magic-context/execute-flush.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"execute-flush.d.ts","sourceRoot":"","sources":["../../../src/hooks/magic-context/execute-flush.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,qBAAqB,CAAC;AAEpD,wBAAgB,YAAY,CAAC,EAAE,EAAE,QAAQ,EAAE,SAAS,EAAE,MAAM,GAAG,MAAM,CA0BpE"}

package/dist/hooks/magic-context/final-wire-token-estimate.d.ts

@@ -0,0 +1,56 @@
+import type { MessageLike } from "./tag-messages";
+export interface MessageTokenEstimate {
+    conversation: number;
+    toolCall: number;
+}
+/** Describe the final three post-transform messages without serializing content. */
+export declare function describeFinalWireTail(messages: readonly MessageLike[]): string;
+/** Count the token-bearing fields in the message representation sent to OpenCode. */
+export declare function estimateMessageTokens(message: MessageLike): MessageTokenEstimate;
+/**
+ * The UTF-8 bytes of the fields `messages` put on the provider wire, the same
+ * fields `estimateMessageTokens` counts; an image counts as `bytesPerToken` bytes
+ * per estimated image token, since the provider bills it by size, not by its
+ * base64 text. Stops as soon as the sum exceeds `abortAboveBytes`. Null when a
+ * field cannot be serialized.
+ */
+export declare function wireContentBytes(messages: readonly MessageLike[], abortAboveBytes: number, bytesPerToken: number): {
+    bytes: number;
+    aborted: boolean;
+} | null;
+export interface FinalWireTokenEstimateInput {
+    messages: readonly MessageLike[];
+    systemPromptTokens: number;
+    providerID: string | undefined;
+    modelID: string | undefined;
+    agentName: string | undefined;
+}
+export interface FinalWireTokenEstimate {
+    tokens: number;
+    trusted: boolean;
+    messageTokens: MessageTokenEstimate;
+    systemTokens: number;
+    toolDefinitionTokens: number | undefined;
+    /**
+     * True when the tool-definition figure is this route's own measurement. When
+     * false, `toolDefinitionTokens` is either unknown or an upper envelope taken
+     * from the largest tool set measured on any route.
+     */
+    toolDefinitionsMeasured?: boolean;
+    /** Unscaled transform-array/system/tool measurement; provider framing is unmeasured. */
+    rawTokens?: number;
+    rawComponents?: {
+        system: number;
+        tools: number;
+        prose: number;
+    };
+    completeness?: "complete" | "partial";
+    componentsComplete?: boolean;
+}
+/**
+ * Estimate the returned transform array plus observed system and tool definitions.
+ * This is not exact provider tokenization: provider framing remains unmeasured.
+ * Fit callers must require trusted, not merely compare a numeric partial estimate.
+ */
+export declare function estimateFinalWireInputTokens(input: FinalWireTokenEstimateInput): FinalWireTokenEstimate;
+//# sourceMappingURL=final-wire-token-estimate.d.ts.map

package/dist/hooks/magic-context/final-wire-token-estimate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"final-wire-token-estimate.d.ts","sourceRoot":"","sources":["../../../src/hooks/magic-context/final-wire-token-estimate.ts"],"names":[],"mappings":"AAUA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAC;AAGlD,MAAM,WAAW,oBAAoB;IACjC,YAAY,EAAE,MAAM,CAAC;IACrB,QAAQ,EAAE,MAAM,CAAC;CACpB;AAwBD,oFAAoF;AACpF,wBAAgB,qBAAqB,CAAC,QAAQ,EAAE,SAAS,WAAW,EAAE,GAAG,MAAM,CAS9E;AA4GD,qFAAqF;AACrF,wBAAgB,qBAAqB,CAAC,OAAO,EAAE,WAAW,GAAG,oBAAoB,CAWhF;AAED;;;;;;GAMG;AACH,wBAAgB,gBAAgB,CAC5B,QAAQ,EAAE,SAAS,WAAW,EAAE,EAChC,eAAe,EAAE,MAAM,EACvB,aAAa,EAAE,MAAM,GACtB;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,OAAO,CAAA;CAAE,GAAG,IAAI,CAkB5C;AAED,MAAM,WAAW,2BAA2B;IACxC,QAAQ,EAAE,SAAS,WAAW,EAAE,CAAC;IACjC,kBAAkB,EAAE,MAAM,CAAC;IAC3B,UAAU,EAAE,MAAM,GAAG,SAAS,CAAC;IAC/B,OAAO,EAAE,MAAM,GAAG,SAAS,CAAC;IAC5B,SAAS,EAAE,MAAM,GAAG,SAAS,CAAC;CACjC;AAED,MAAM,WAAW,sBAAsB;IACnC,MAAM,EAAE,MAAM,CAAC;IACf,OAAO,EAAE,OAAO,CAAC;IACjB,aAAa,EAAE,oBAAoB,CAAC;IACpC,YAAY,EAAE,MAAM,CAAC;IACrB,oBAAoB,EAAE,MAAM,GAAG,SAAS,CAAC;IACzC;;;;OAIG;IACH,uBAAuB,CAAC,EAAE,OAAO,CAAC;IAClC,wFAAwF;IACxF,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,aAAa,CAAC,EAAE;QAAE,MAAM,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAA;KAAE,CAAC;IACjE,YAAY,CAAC,EAAE,UAAU,GAAG,SAAS,CAAC;IACtC,kBAAkB,CAAC,EAAE,OAAO,CAAC;CAChC;AAED;;;;GAIG;AACH,wBAAgB,4BAA4B,CACxC,KAAK,EAAE,2BAA2B,GACnC,sBAAsB,CAkExB"}

package/dist/hooks/magic-context/fold-execution-gate.d.ts

@@ -0,0 +1,2 @@
+export declare function foldExecutesThisPass(foldDue: boolean, materialized: boolean): boolean;
+//# sourceMappingURL=fold-execution-gate.d.ts.map

package/dist/hooks/magic-context/fold-execution-gate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fold-execution-gate.d.ts","sourceRoot":"","sources":["../../../src/hooks/magic-context/fold-execution-gate.ts"],"names":[],"mappings":"AAAA,wBAAgB,oBAAoB,CAAC,OAAO,EAAE,OAAO,EAAE,YAAY,EAAE,OAAO,GAAG,OAAO,CAErF"}

package/dist/hooks/magic-context/format-bytes.d.ts

@@ -0,0 +1,2 @@
+export { formatBytes } from "../../shared/format-bytes";
+//# sourceMappingURL=format-bytes.d.ts.map

package/dist/hooks/magic-context/format-bytes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"format-bytes.d.ts","sourceRoot":"","sources":["../../../src/hooks/magic-context/format-bytes.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,2BAA2B,CAAC"}

package/dist/hooks/magic-context/heuristic-cleanup.d.ts

@@ -0,0 +1,48 @@
+import type { ContextDatabase } from "../../features/magic-context/storage";
+import type { TagEntry } from "../../features/magic-context/types";
+import { type CavemanCleanupConfig } from "./caveman-cleanup";
+import type { DroppedTokenReduction } from "./dropped-token-estimate";
+import type { MessageLike, TagTarget } from "./tag-messages";
+export declare function applyHeuristicCleanup(sessionId: string, db: ContextDatabase, targets: Map<number, TagTarget>, messageTagNumbers: Map<MessageLike, number>, config: {
+    /** Exact token-window membership in tag-number space. */
+    protectedTagNumbers: ReadonlySet<number>;
+    /**
+     * Exact token-window cutoff in tag-number space. A null cutoff means the
+     * persisted tool population is empty and applies no tag-number threshold.
+     */
+    protectedCutoff: number | null;
+    /**
+     * Tiered target-headroom emergency drop. Provided only on force-materialization
+     * passes at or above the derived force band; undefined on routine execute
+     * passes, which do not perform age-based tool drops. When
+     * present, the emergency drop runs before dedup/injection-strip.
+     */
+    emergency?: {
+        currentTotalInputTokens: number;
+        ceilingTokens: number;
+        usagePercentage?: number;
+        /** Another mutation already rewrites the cached prefix on this pass. */
+        passAlreadyPriced?: boolean;
+    };
+    /**
+     * Whether ordinary deduplication, injection stripping, and caveman
+     * compression may first-apply on this pass. Emergency selection remains
+     * independent so a force-band edge can still reclaim enough headroom.
+     */
+    routine?: boolean;
+    /**
+     * Age-tier caveman text compression settings. Caller is responsible
+     * for forwarding this only for primary sessions where caveman is enabled.
+     */
+    caveman?: CavemanCleanupConfig;
+}, preloadedTags?: TagEntry[]): {
+    droppedTools: number;
+    deduplicatedTools: number;
+    droppedInjections: number;
+    emergencyDroppedTools: number;
+    emergencyReclaimedTokens: number;
+    compressedTextTags: number;
+    mutatedTextTags: number;
+    droppedTokenReductions: DroppedTokenReduction[];
+};
+//# sourceMappingURL=heuristic-cleanup.d.ts.map

package/dist/hooks/magic-context/heuristic-cleanup.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"heuristic-cleanup.d.ts","sourceRoot":"","sources":["../../../src/hooks/magic-context/heuristic-cleanup.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,sCAAsC,CAAC;AAY5E,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,oCAAoC,CAAC;AAGnE,OAAO,EAAuB,KAAK,oBAAoB,EAAE,MAAM,mBAAmB,CAAC;AACnF,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,0BAA0B,CAAC;AAQtE,OAAO,KAAK,EAAE,WAAW,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC;AA6B7D,wBAAgB,qBAAqB,CACjC,SAAS,EAAE,MAAM,EACjB,EAAE,EAAE,eAAe,EACnB,OAAO,EAAE,GAAG,CAAC,MAAM,EAAE,SAAS,CAAC,EAC/B,iBAAiB,EAAE,GAAG,CAAC,WAAW,EAAE,MAAM,CAAC,EAC3C,MAAM,EAAE;IACJ,yDAAyD;IACzD,mBAAmB,EAAE,WAAW,CAAC,MAAM,CAAC,CAAC;IACzC;;;OAGG;IACH,eAAe,EAAE,MAAM,GAAG,IAAI,CAAC;IAC/B;;;;;OAKG;IACH,SAAS,CAAC,EAAE;QACR,uBAAuB,EAAE,MAAM,CAAC;QAChC,aAAa,EAAE,MAAM,CAAC;QACtB,eAAe,CAAC,EAAE,MAAM,CAAC;QACzB,wEAAwE;QACxE,iBAAiB,CAAC,EAAE,OAAO,CAAC;KAC/B,CAAC;IACF;;;;OAIG;IACH,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB;;;OAGG;IACH,OAAO,CAAC,EAAE,oBAAoB,CAAC;CAClC,EACD,aAAa,CAAC,EAAE,QAAQ,EAAE,GAC3B;IACC,YAAY,EAAE,MAAM,CAAC;IACrB,iBAAiB,EAAE,MAAM,CAAC;IAC1B,iBAAiB,EAAE,MAAM,CAAC;IAC1B,qBAAqB,EAAE,MAAM,CAAC;IAC9B,wBAAwB,EAAE,MAAM,CAAC;IACjC,kBAAkB,EAAE,MAAM,CAAC;IAC3B,eAAe,EAAE,MAAM,CAAC;IACxB,sBAAsB,EAAE,qBAAqB,EAAE,CAAC;CACnD,CAwSA"}

package/dist/hooks/magic-context/historian-no-fire-cause.d.ts

@@ -0,0 +1,5 @@
+export declare const HISTORIAN_NO_FIRE_CAUSES: readonly ["in_flight", "cheap_skip", "no_new_raw_history", "raw_history_unavailable", "redundancy_skip", "protected_tail", "below_proactive_floor", "below_min_chunk", "drain_budget", "missing_boundary_snapshot", "stale_boundary_snapshot", "invalid_chunk_coverage", "credential_unavailable", "provider_unknown", "model_unknown", "runner_resolution_failed"];
+export type HistorianNoFireCause = (typeof HISTORIAN_NO_FIRE_CAUSES)[number];
+export declare const RUNNER_REFUSAL_CANONICAL_CAUSES: readonly ["credential_unavailable", "provider_unknown", "model_unknown", "runner_resolution_failed"];
+export type RunnerRefusalCanonicalCause = (typeof RUNNER_REFUSAL_CANONICAL_CAUSES)[number];
+//# sourceMappingURL=historian-no-fire-cause.d.ts.map

package/dist/hooks/magic-context/historian-no-fire-cause.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"historian-no-fire-cause.d.ts","sourceRoot":"","sources":["../../../src/hooks/magic-context/historian-no-fire-cause.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,wBAAwB,qWAiB3B,CAAC;AAEX,MAAM,MAAM,oBAAoB,GAAG,CAAC,OAAO,wBAAwB,CAAC,CAAC,MAAM,CAAC,CAAC;AAE7E,eAAO,MAAM,+BAA+B,sGAKQ,CAAC;AAErD,MAAM,MAAM,2BAA2B,GAAG,CAAC,OAAO,+BAA+B,CAAC,CAAC,MAAM,CAAC,CAAC"}