@retaw106/mmc-oc 0.0.0-stage → 1.2.2

package/dist/features/magic-context/mural/storage-mural-cues.d.ts

@@ -0,0 +1,65 @@
+import { type Database } from "../../../shared/sqlite";
+/**
+ * Per-memory mural cue storage (v65). The (since-removed) compress-cues task
+ * wrote one
+ *  compressed pidgin cue per memory content version onto the `memories` table
+ *  (columns mural_cue / mural_cue_hash / mural_cue_at plus the rejection latch).
+ *  resolveMural reads the hash-current ones and packs them deterministically at
+ *  inject time.
+ *
+ * These are derived render-cache columns, not prompt-cache bytes. TypeScript authority writes them
+ * through the narrow privileged writer; the module facade sends the same
+ * column-only mutation and the changefeed mirrors it back here. Authority
+ * triggers still guard every update to a managed memory row.
+ */
+/**
+ * The staleness key: sha256 of the RAW memory content the cue was compressed
+ * FROM. Any edit to the content changes this hash, so a stored cue whose hash no
+ * longer matches the current content is detected as stale — re-selected by the
+ * compress-cues gate and excluded by resolveMural until recompressed. This is
+ * deliberately distinct from `normalizedHash` (md5 of normalized text used for
+ * dedup): cue staleness must react to every content change, including
+ * whitespace/case edits that normalization would erase.
+ */
+export declare function computeCueContentHash(content: string): string;
+/** Column-guard for pre-v65 databases so cue reads/writes degrade to a no-op
+ *  rather than throwing "no such column" on an un-migrated DB. */
+export declare function hasMuralCueColumns(db: Database): boolean;
+/** The rejection latch was added after the base cue columns. Keep this guard so
+ *  a process inspecting a v65-v74 database can still read the cue cache. */
+export declare function hasMuralCueRejectionCountColumn(db: Database): boolean;
+export interface MuralCueState {
+    /** The stored compressed cue, or null when never compressed. */
+    cue: string | null;
+    /** sha256 of the content the stored cue was compressed from, or null. */
+    hash: string | null;
+    /** Number of validation failures for the content identified by `hash`. */
+    rejectionCount?: number;
+}
+/**
+ * Read the stored cue state for a set of memory ids. Ids absent from the map
+ * have no row (or the column set is missing on a pre-v65 DB). Used by the
+ * compress-cues gate and by resolveMural's hash-current filter.
+ */
+export declare function getMuralCueState(db: Database, memoryIds: readonly number[]): Map<number, MuralCueState>;
+/**
+ * True when a memory needs (re)compression: it has no cue yet, or the stored cue
+ * was computed from different content (hash mismatch). Callers pass the memory's
+ * CURRENT content so the check reacts to edits.
+ */
+export declare function memoryNeedsCue(state: MuralCueState | undefined, currentContent: string): boolean;
+/**
+ * Write a compressed cue as a column-only update. `contentHash` MUST be the
+ * hash of the content that was actually compressed (not a re-hash of the row's
+ * current content): if the memory was edited mid-run, storing the prompt-time
+ * hash leaves mural_cue_hash != sha256(current content), so resolveMural
+ * excludes the now-stale cue and the compress-cues gate re-selects the memory
+ * next run. Cache-neutral: the mural is rendered on demand from these columns,
+ * not injected as part of the m[0] baseline bytes.
+ */
+export declare function setMuralCue(db: Database, projectPath: string, id: number, cue: string, contentHash: string): void;
+/** Record one validation rejection for the selected content version. The cue hash
+ * doubles as the latch key while the cue remains NULL; an edited memory therefore
+ * starts at one rejection even if an old rejection row is still present. */
+export declare function recordMuralCueRejection(db: Database, projectPath: string, id: number, contentHash: string): number;
+//# sourceMappingURL=storage-mural-cues.d.ts.map

package/dist/features/magic-context/mural/storage-mural-cues.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"storage-mural-cues.d.ts","sourceRoot":"","sources":["../../../../src/features/magic-context/mural/storage-mural-cues.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,KAAK,QAAQ,EAAwB,MAAM,wBAAwB,CAAC;AAE7E;;;;;;;;;;;;GAYG;AAEH;;;;;;;;GAQG;AACH,wBAAgB,qBAAqB,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAE7D;AAKD;kEACkE;AAClE,wBAAgB,kBAAkB,CAAC,EAAE,EAAE,QAAQ,GAAG,OAAO,CAOxD;AAED;4EAC4E;AAC5E,wBAAgB,+BAA+B,CAAC,EAAE,EAAE,QAAQ,GAAG,OAAO,CAOrE;AAED,MAAM,WAAW,aAAa;IAC1B,gEAAgE;IAChE,GAAG,EAAE,MAAM,GAAG,IAAI,CAAC;IACnB,yEAAyE;IACzE,IAAI,EAAE,MAAM,GAAG,IAAI,CAAC;IACpB,0EAA0E;IAC1E,cAAc,CAAC,EAAE,MAAM,CAAC;CAC3B;AAED;;;;GAIG;AACH,wBAAgB,gBAAgB,CAC5B,EAAE,EAAE,QAAQ,EACZ,SAAS,EAAE,SAAS,MAAM,EAAE,GAC7B,GAAG,CAAC,MAAM,EAAE,aAAa,CAAC,CAgC5B;AAED;;;;GAIG;AACH,wBAAgB,cAAc,CAAC,KAAK,EAAE,aAAa,GAAG,SAAS,EAAE,cAAc,EAAE,MAAM,GAAG,OAAO,CAGhG;AAED;;;;;;;;GAQG;AACH,wBAAgB,WAAW,CACvB,EAAE,EAAE,QAAQ,EACZ,WAAW,EAAE,MAAM,EACnB,EAAE,EAAE,MAAM,EACV,GAAG,EAAE,MAAM,EACX,WAAW,EAAE,MAAM,GACpB,IAAI,CAkBN;AAED;;4EAE4E;AAC5E,wBAAgB,uBAAuB,CACnC,EAAE,EAAE,QAAQ,EACZ,WAAW,EAAE,MAAM,EACnB,EAAE,EAAE,MAAM,EACV,WAAW,EAAE,MAAM,GACpB,MAAM,CAsBR"}

package/dist/features/magic-context/no-content-compartment.d.ts

@@ -0,0 +1,12 @@
+/** Empty payloads are boundary-only markers for raw rows excluded by historian filters, not summaries. */
+export declare function isNoContentCompartment(row: {
+    title: string;
+    content: string;
+    p1?: string | null;
+    p2?: string | null;
+    p3?: string | null;
+    p4?: string | null;
+}): boolean;
+/** SQL equivalent for readers that count summary rows without loading their payloads. */
+export declare const HAS_COMPARTMENT_CONTENT_SQL = "(title <> '' OR content <> '' OR COALESCE(p1, '') <> '' OR COALESCE(p2, '') <> '' OR COALESCE(p3, '') <> '' OR COALESCE(p4, '') <> '')";
+//# sourceMappingURL=no-content-compartment.d.ts.map

package/dist/features/magic-context/no-content-compartment.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"no-content-compartment.d.ts","sourceRoot":"","sources":["../../../src/features/magic-context/no-content-compartment.ts"],"names":[],"mappings":"AAAA,0GAA0G;AAC1G,wBAAgB,sBAAsB,CAAC,GAAG,EAAE;IACxC,KAAK,EAAE,MAAM,CAAC;IACd,OAAO,EAAE,MAAM,CAAC;IAChB,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;CACtB,GAAG,OAAO,CAEV;AAED,yFAAyF;AACzF,eAAO,MAAM,2BAA2B,2IACoG,CAAC"}

package/dist/features/magic-context/opencode2-relabel.d.ts

@@ -0,0 +1,132 @@
+/**
+ * Conditional `opencode`/`opencode2` harness relabel driven by host-store evidence
+ * (migration v87).
+ *
+ * Background. Migration v85 rewrote EVERY `opencode2` row to `opencode` on the
+ * premise that no released Magic Context had ever run on a real OpenCode 2 host,
+ * so every such row had to be the OpenCode 1.x mislabel (ungated `setup()` locked
+ * the harness to "opencode2" on a 1.18.x seat). That premise held for most
+ * installs and was wrong for early adopters: a store written by a genuine
+ * OpenCode 2 host had its rows relabelled, the 2 host kept writing `opencode2`,
+ * and every tag and session row it had already written became invisible to it
+ * (issue #475: 2,788 tags and 32 session_meta rows).
+ *
+ * What this does instead. The label is decided PER SESSION from the OpenCode
+ * store itself — the same store the runtime reads — and only when that store
+ * answers. The rule is "whoever wrote the session most recently owns the label":
+ *
+ *   newest 2.x activity  > newest 1.x activity → `opencode2`
+ *   newest 1.x activity  > newest 2.x activity → `opencode`
+ *   equal, or the session is in neither generation's tables → leave unchanged
+ *
+ * 2.x activity is read from `session_message`/`session_v2` and counted only when
+ * `session_v2` exists: a 1.18.x store ships an (empty) `session_message` table
+ * too, so `session_v2` is the table that proves a 2.x host has touched the store
+ * (PR #477). 1.x activity is read from `message.time_updated` and, for sessions
+ * with no messages, the `session.time_updated` row the host maintains.
+ *
+ * The equal case is not a theoretical tie. When an OpenCode 2 host migrates a
+ * 1.18.x store it copies each `session` row into `session_v2` with
+ * `time_created`/`time_updated` PRESERVED and moves no messages (observed with
+ * the real 1.18.30 and 2.0.5 binaries; pinned in
+ * `__fixtures__/opencode-store-shapes.json`). A migrated-but-never-used session
+ * therefore reports the same timestamp on both sides, which is exactly "no
+ * evidence of who wrote last" — so the stored label stands. Once either host
+ * writes again, its side becomes strictly newer and wins, which is what makes a
+ * downgraded store (2.x migrated, then 1.x used again) resolve to `opencode`.
+ *
+ * When the store cannot be resolved or read, NOTHING is relabelled: the affected
+ * session ids are recorded in `schema_migrations_meta` so `magic-context doctor`
+ * can report the unresolved repair, and the situation is logged once.
+ */
+import { Database } from "../../shared/sqlite";
+/** The two harness labels this repair moves rows between. */
+export type RelabelHarness = "opencode" | "opencode2";
+/** `schema_migrations_meta` key holding the unresolved-repair report for doctor. */
+export declare const OPENCODE2_RELABEL_STATE_KEY = "v87_opencode2_relabel";
+/**
+ * Tables whose harness twin cannot simply be relabelled: their PRIMARY KEY or
+ * UNIQUE key contains `harness`, so the same natural key can hold one row per
+ * label. v85 resolved these by keeping the newer row; v87 applies the SAME rule
+ * in whichever direction the session resolves, with a tie keeping the row that
+ * already carries the resolved label.
+ *
+ * `tags` is deliberately absent: its UNIQUE key is (session_id, tag_number) and
+ * does not mention harness, so relabelling can never collide there. Duplicate
+ * tag rows for one message are left alone on purpose — the tagger binds a
+ * duplicate composite key to the LOWEST tag_number row it finds
+ * (`storage-tags.ts`: `SELECT tag_number FROM tags WHERE session_id = ? AND
+ * message_id = ? ORDER BY tag_number ASC LIMIT 1`, and the matching
+ * `ORDER BY tag_number ASC` lookup for tool owners) and never deletes the newer
+ * one, so neither does this repair.
+ */
+export declare const V87_HARNESS_TWIN_RULES: ReadonlyArray<{
+    table: string;
+    /** Natural-key columns other than `harness`. */
+    keyColumns: readonly string[];
+    /** True when the incoming (being relabelled) row is newer than the existing one. */
+    incomingIsNewer: string;
+}>;
+export interface OpenCode2RelabelReport {
+    /**
+     * `no_candidates` — nothing in this database carries an opencode/opencode2 label.
+     * `resolved` — the host store answered; see `relabelledSessions`.
+     * `unresolved` — no readable host store, so nothing was changed.
+     */
+    status: "no_candidates" | "resolved" | "unresolved";
+    reason?: "store_not_found" | "store_unreadable" | "store_schema_unknown";
+    storePath: string | null;
+    /** Sessions carrying an opencode/opencode2 label when the repair ran. */
+    candidateSessionIds: string[];
+    /** Sessions whose rows moved, with the label they moved to. */
+    relabelledSessions: Array<{
+        sessionId: string;
+        harness: RelabelHarness;
+    }>;
+}
+/** The unresolved report doctor reads back out of `schema_migrations_meta`. */
+export interface UnresolvedOpenCode2Relabel {
+    reason: string;
+    /** Where the store was looked for when the repair ran. */
+    lookedFor: string;
+    sessionIds: string[];
+    recordedAt: number;
+}
+interface HarnessTableShape {
+    table: string;
+    hasSessionId: boolean;
+}
+export interface EvidenceStore {
+    newestV1Activity(sessionId: string): number | null;
+    newestV2Activity(sessionId: string): number | null;
+}
+type MinimalDb = Pick<Database, "prepare" | "exec">;
+/**
+ * The v85 tables present in THIS database that carry a harness label, split by
+ * whether the label belongs to a session. Tables keyed by harness alone
+ * (`message_history_orphan_sweep`, `session_project_backfill_state`) are
+ * per-harness cursors, not session state: no session evidence can speak for
+ * them, so this repair leaves them where they are rather than guessing.
+ */
+export declare function listSessionScopedHarnessTables(db: MinimalDb, tables: readonly string[]): HarnessTableShape[];
+/** Decide one session's label from the store evidence. `null` means "no evidence". */
+export declare function resolveHarnessFromEvidence(evidence: EvidenceStore, sessionId: string): RelabelHarness | null;
+/**
+ * The unresolved-repair report for `magic-context doctor`, or null when the
+ * repair had nothing to do or completed against a readable store.
+ */
+export declare function readUnresolvedOpenCode2Relabel(db: MinimalDb): UnresolvedOpenCode2Relabel | null;
+export declare function formatUnresolvedOpenCode2RelabelDoctorLines(state: UnresolvedOpenCode2Relabel, maxSessions?: number): string[];
+export interface RepairOptions {
+    /** Tables v85 relabelled; the repair covers exactly the same set. */
+    tables: readonly string[];
+    env?: NodeJS.ProcessEnv;
+}
+/**
+ * Relabel each session's rows to the generation that wrote that session most
+ * recently, in both directions, using the OpenCode store as the only evidence.
+ * Idempotent: a second run reads the same evidence and finds nothing to move.
+ */
+export declare function repairOpenCode2HarnessLabels(db: Database, options: RepairOptions): OpenCode2RelabelReport;
+export {};
+//# sourceMappingURL=opencode2-relabel.d.ts.map

package/dist/features/magic-context/opencode2-relabel.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"opencode2-relabel.d.ts","sourceRoot":"","sources":["../../../src/features/magic-context/opencode2-relabel.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwCG;AASH,OAAO,EAAE,QAAQ,EAAE,MAAM,qBAAqB,CAAC;AAE/C,6DAA6D;AAC7D,MAAM,MAAM,cAAc,GAAG,UAAU,GAAG,WAAW,CAAC;AAEtD,oFAAoF;AACpF,eAAO,MAAM,2BAA2B,0BAA0B,CAAC;AAEnE;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,sBAAsB,EAAE,aAAa,CAAC;IAC/C,KAAK,EAAE,MAAM,CAAC;IACd,gDAAgD;IAChD,UAAU,EAAE,SAAS,MAAM,EAAE,CAAC;IAC9B,oFAAoF;IACpF,eAAe,EAAE,MAAM,CAAC;CAC3B,CAqBA,CAAC;AAEF,MAAM,WAAW,sBAAsB;IACnC;;;;OAIG;IACH,MAAM,EAAE,eAAe,GAAG,UAAU,GAAG,YAAY,CAAC;IACpD,MAAM,CAAC,EAAE,iBAAiB,GAAG,kBAAkB,GAAG,sBAAsB,CAAC;IACzE,SAAS,EAAE,MAAM,GAAG,IAAI,CAAC;IACzB,yEAAyE;IACzE,mBAAmB,EAAE,MAAM,EAAE,CAAC;IAC9B,+DAA+D;IAC/D,kBAAkB,EAAE,KAAK,CAAC;QAAE,SAAS,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,cAAc,CAAA;KAAE,CAAC,CAAC;CAC7E;AAED,+EAA+E;AAC/E,MAAM,WAAW,0BAA0B;IACvC,MAAM,EAAE,MAAM,CAAC;IACf,0DAA0D;IAC1D,SAAS,EAAE,MAAM,CAAC;IAClB,UAAU,EAAE,MAAM,EAAE,CAAC;IACrB,UAAU,EAAE,MAAM,CAAC;CACtB;AAED,UAAU,iBAAiB;IACvB,KAAK,EAAE,MAAM,CAAC;IACd,YAAY,EAAE,OAAO,CAAC;CACzB;AAED,MAAM,WAAW,aAAa;IAC1B,gBAAgB,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAAC;IACnD,gBAAgB,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAAC;CACtD;AAMD,KAAK,SAAS,GAAG,IAAI,CAAC,QAAQ,EAAE,SAAS,GAAG,MAAM,CAAC,CAAC;AAgBpD;;;;;;GAMG;AACH,wBAAgB,8BAA8B,CAC1C,EAAE,EAAE,SAAS,EACb,MAAM,EAAE,SAAS,MAAM,EAAE,GAC1B,iBAAiB,EAAE,CASrB;AA8ED,sFAAsF;AACtF,wBAAgB,0BAA0B,CACtC,QAAQ,EAAE,aAAa,EACvB,SAAS,EAAE,MAAM,GAClB,cAAc,GAAG,IAAI,CAOvB;AAqED;;;GAGG;AACH,wBAAgB,8BAA8B,CAAC,EAAE,EAAE,SAAS,GAAG,0BAA0B,GAAG,IAAI,CAE/F;AAED,wBAAgB,2CAA2C,CACvD,KAAK,EAAE,0BAA0B,EACjC,WAAW,SAAK,GACjB,MAAM,EAAE,CAWV;AA0BD,MAAM,WAAW,aAAa;IAC1B,qEAAqE;IACrE,MAAM,EAAE,SAAS,MAAM,EAAE,CAAC;IAC1B,GAAG,CAAC,EAAE,MAAM,CAAC,UAAU,CAAC;CAC3B;AAED;;;;GAIG;AACH,wBAAgB,4BAA4B,CACxC,EAAE,EAAE,QAAQ,EACZ,OAAO,EAAE,aAAa,GACvB,sBAAsB,CAuGxB"}

package/dist/features/magic-context/overflow-detection.d.ts

@@ -0,0 +1,108 @@
+import type { ContextLimitProvenance } from "../../shared/context-limit-provenance";
+/**
+ * Provider-agnostic context-overflow error detection.
+ *
+ * When a provider rejects a request because the prompt exceeds its context
+ * window, we want to react:
+ *   1. Trigger emergency recovery (historian + aggressive drops) so the next
+ *      turn fits.
+ *   2. If the error message reveals the real context limit, persist it as a
+ *      session-specific override so pressure math is accurate going forward.
+ *
+ * Pattern list adapted from OpenCode's `packages/opencode/src/provider/error.ts`
+ * (BSD-licensed). We keep our own copy rather than importing OpenCode internals
+ * so the plugin stays decoupled from OpenCode versioning.
+ *
+ * References:
+ *   - OpenCode overflow detection (origin of patterns):
+ *     https://github.com/sst/opencode/blob/main/packages/opencode/src/provider/error.ts
+ *   - Adapted originally from:
+ *     https://github.com/earendil-works/pi-mono/blob/main/packages/ai/src/utils/overflow.ts
+ */
+/**
+ * Regexes that match provider-reported context-overflow errors. Keep in sync
+ * with upstream OpenCode patterns — new providers can be added here as they
+ * emerge.
+ */
+export declare const OVERFLOW_PATTERNS: ReadonlyArray<RegExp>;
+export interface ReportedContextLimit {
+    value: number;
+    provenance: ContextLimitProvenance;
+}
+export interface ThinkingBindingMismatchDetection {
+    isBindingMismatch: boolean;
+    /** Stable provider message substring used for diagnostics. */
+    matchedPattern?: string;
+    /**
+     * Diagnostics only: the provider's path to the first rejected thinking block
+     * (for example `messages.1.content.0`). It indexes the provider request array
+     * after the host lowered it, not host message ids, so recovery never uses it
+     * to pick a message.
+     */
+    failingBlockPath?: string;
+    /** Diagnostics only: the provider's path to the first changed prefix position. */
+    firstChangedPath?: string;
+}
+export interface OverflowDetection {
+    /** True if the error message matches a known overflow pattern. */
+    isOverflow: boolean;
+    /** Provider-reported token count for the rejected input, when present. */
+    reportedInputTokens?: number;
+    /** Reported context limit in tokens, if extractable from the message. */
+    reportedLimit?: number;
+    /** Whether the number is a prompt-only ceiling or a combined context window. */
+    reportedLimitProvenance?: ContextLimitProvenance;
+    /** The pattern that matched, useful for logging/diagnostics. */
+    matchedPattern?: string;
+}
+/**
+ * Extract an error message from any reasonable shape. Events from OpenCode can
+ * deliver errors as strings, Error instances, or plain objects with `message`.
+ */
+export declare function extractErrorMessage(error: unknown): string;
+/**
+ * Classify Anthropic's thinking-prefix binding rejection (Claude Fable 5.1 and
+ * Claude Opus 5.5). Only the stable phrase is matched; the surrounding prose
+ * and SDK wrappers vary. The live 400 (captured in
+ * docs/reports/anthropic-thinking-binding.md) carries no message id, only
+ * provider request-array paths, so the result never names a host message.
+ * Source: https://platform.claude.com/docs/en/build-with-claude/preserved-thinking
+ */
+export declare function detectThinkingBindingMismatch(error: unknown): ThinkingBindingMismatchDetection;
+/**
+ * Claude models whose signed thinking blocks Anthropic binds to the request
+ * prefix, as `[family, major, minor]`. The source of truth is Anthropic's
+ * preserved-thinking page
+ * (https://platform.claude.com/docs/en/build-with-claude/preserved-thinking,
+ * "Keeping the prefix unchanged"); add a row when it names a new model.
+ */
+export declare const PREFIX_BOUND_THINKING_MODELS: ReadonlyArray<readonly [string, number, number]>;
+/**
+ * True for a model in PREFIX_BOUND_THINKING_MODELS on any route. Accounts
+ * created on or after 2026-08-31 enforce the binding on the Claude API, Vertex
+ * and Bedrock, so the provider is deliberately ignored. Proactive stripping
+ * runs only when a pass already rebuilds the cached prefix: a false positive
+ * costs reasoning on those passes, a false negative risks a binding 400.
+ */
+export declare function isPrefixBoundThinkingModel(_providerID: string | null | undefined, modelID: string | null | undefined): boolean;
+/**
+ * True only for canonical Anthropic Fable 5.1 model identifiers. Binding
+ * recovery uses isPrefixBoundThinkingModel instead, which also covers Opus 5.5,
+ * Sonnet 5.5 and cloud routes. The variant-cache policy uses this narrower
+ * check to recognize Fable 5.1, whose cached prefix survives effort changes;
+ * that measured cache behavior is separate from prefix binding.
+ */
+export declare function isFable51ThinkingBindingModel(providerID: string | null | undefined, modelID: string | null | undefined): boolean;
+/**
+ * Detect whether an error represents a provider-side context-overflow
+ * rejection, and optionally extract the reported limit.
+ */
+export declare function detectOverflow(error: unknown): OverflowDetection;
+/**
+ * Extract the reported context-limit (in tokens) from an error message if one
+ * of the known patterns matches. Returns undefined when no plausible number
+ * can be extracted. Guards against false matches via plausibility clamp.
+ */
+export declare function parseReportedInputTokens(message: string): number | undefined;
+export declare function parseReportedLimit(message: string): ReportedContextLimit | undefined;
+//# sourceMappingURL=overflow-detection.d.ts.map

package/dist/features/magic-context/overflow-detection.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"overflow-detection.d.ts","sourceRoot":"","sources":["../../../src/features/magic-context/overflow-detection.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,uCAAuC,CAAC;AAEpF;;;;;;;;;;;;;;;;;;;GAmBG;AAEH;;;;GAIG;AACH,eAAO,MAAM,iBAAiB,EAAE,aAAa,CAAC,MAAM,CAwBnD,CAAC;AA6DF,MAAM,WAAW,oBAAoB;IACjC,KAAK,EAAE,MAAM,CAAC;IACd,UAAU,EAAE,sBAAsB,CAAC;CACtC;AAED,MAAM,WAAW,gCAAgC;IAC7C,iBAAiB,EAAE,OAAO,CAAC;IAC3B,8DAA8D;IAC9D,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB;;;;;OAKG;IACH,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,kFAAkF;IAClF,gBAAgB,CAAC,EAAE,MAAM,CAAC;CAC7B;AAMD,MAAM,WAAW,iBAAiB;IAC9B,kEAAkE;IAClE,UAAU,EAAE,OAAO,CAAC;IACpB,0EAA0E;IAC1E,mBAAmB,CAAC,EAAE,MAAM,CAAC;IAC7B,yEAAyE;IACzE,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,gFAAgF;IAChF,uBAAuB,CAAC,EAAE,sBAAsB,CAAC;IACjD,gEAAgE;IAChE,cAAc,CAAC,EAAE,MAAM,CAAC;CAC3B;AAED;;;GAGG;AACH,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,CA6B1D;AAsBD;;;;;;;GAOG;AACH,wBAAgB,6BAA6B,CAAC,KAAK,EAAE,OAAO,GAAG,gCAAgC,CAiB9F;AAED;;;;;;GAMG;AACH,eAAO,MAAM,4BAA4B,EAAE,aAAa,CAAC,SAAS,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAIzF,CAAC;AAYF;;;;;;GAMG;AACH,wBAAgB,0BAA0B,CACtC,WAAW,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,EACtC,OAAO,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,GACnC,OAAO,CAGT;AAED;;;;;;GAMG;AACH,wBAAgB,6BAA6B,CACzC,UAAU,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,EACrC,OAAO,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,GACnC,OAAO,CAGT;AAED;;;GAGG;AACH,wBAAgB,cAAc,CAAC,KAAK,EAAE,OAAO,GAAG,iBAAiB,CAiChE;AAED;;;;GAIG;AACH,wBAAgB,wBAAwB,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAgB5E;AAED,wBAAgB,kBAAkB,CAAC,OAAO,EAAE,MAAM,GAAG,oBAAoB,GAAG,SAAS,CAapF"}

package/dist/features/magic-context/pi-content-decisions.d.ts

@@ -0,0 +1,9 @@
+import type { Database } from "../../shared/sqlite";
+export declare const PI_CONTENT_DECISION_LIMIT = 4096;
+export type PiContentDecisionKind = "reminder-strip" | "seam-temporal-strip";
+export declare function encodePiContentDecision(kind: PiContentDecisionKind, messageId: string): string;
+export declare function decodePiContentDecision(value: string): [PiContentDecisionKind, string] | null;
+export declare function getPiContentDecisions(db: Database, sessionId: string): Set<string>;
+/** Persist before changing bytes. A full ledger declines new cleanup rather than evicting live replay choices. */
+export declare function freezePiContentDecision(db: Database, sessionId: string, kind: PiContentDecisionKind, messageId: string): boolean;
+//# sourceMappingURL=pi-content-decisions.d.ts.map

package/dist/features/magic-context/pi-content-decisions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pi-content-decisions.d.ts","sourceRoot":"","sources":["../../../src/features/magic-context/pi-content-decisions.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,qBAAqB,CAAC;AAIpD,eAAO,MAAM,yBAAyB,OAAO,CAAC;AAC9C,MAAM,MAAM,qBAAqB,GAAG,gBAAgB,GAAG,qBAAqB,CAAC;AAE7E,wBAAgB,uBAAuB,CAAC,IAAI,EAAE,qBAAqB,EAAE,SAAS,EAAE,MAAM,GAAG,MAAM,CAE9F;AAED,wBAAgB,uBAAuB,CAAC,KAAK,EAAE,MAAM,GAAG,CAAC,qBAAqB,EAAE,MAAM,CAAC,GAAG,IAAI,CAgB7F;AAWD,wBAAgB,qBAAqB,CAAC,EAAE,EAAE,QAAQ,EAAE,SAAS,EAAE,MAAM,GAAG,GAAG,CAAC,MAAM,CAAC,CAWlF;AAED,kHAAkH;AAClH,wBAAgB,uBAAuB,CACnC,EAAE,EAAE,QAAQ,EACZ,SAAS,EAAE,MAAM,EACjB,IAAI,EAAE,qBAAqB,EAC3B,SAAS,EAAE,MAAM,GAClB,OAAO,CAmDT"}

package/dist/features/magic-context/project-identity.d.ts

@@ -0,0 +1,2 @@
+export * from "./memory/project-identity";
+//# sourceMappingURL=project-identity.d.ts.map

package/dist/features/magic-context/project-identity.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"project-identity.d.ts","sourceRoot":"","sources":["../../../src/features/magic-context/project-identity.ts"],"names":[],"mappings":"AAAA,cAAc,2BAA2B,CAAC"}

package/dist/features/magic-context/protection-window.d.ts

@@ -0,0 +1,79 @@
+import type { Database } from "../../shared/sqlite";
+export type CoordinateSpace = "tag-number" | "row-identity";
+export interface ProtectionWindowRow {
+    tag_number?: number;
+    tagNumber?: number;
+    row_identity?: number | string;
+    id?: number | string;
+    kind?: string;
+    type?: string;
+    token_count?: number | null;
+    tokenCount?: number | null;
+    input_token_count?: number | null;
+    inputTokenCount?: number | null;
+    status?: string;
+    message_id?: string;
+    messageId?: string;
+}
+export interface TagNumberProjection {
+    coordinateSpace: "tag-number";
+    tagNumbers: Set<number>;
+}
+export interface RowIdentityProjection<T = number | string> {
+    coordinateSpace: "row-identity";
+    rowIdentities: Set<T>;
+}
+export interface OrdinalCutoffProjection {
+    coordinateSpace: "tag-number";
+    cutoff: number | null;
+}
+export interface ProtectionWindowStatus {
+    floor: number;
+    protectedCount: number;
+    protectedMass: number;
+}
+export interface ProtectionWindowResult<TRow = ProtectionWindowRow, TIdentity = number | string> {
+    memberRows: TRow[];
+    memberRowKeys: Set<string>;
+    tagNumberSet: TagNumberProjection;
+    rowIdentitySet: RowIdentityProjection<TIdentity>;
+    ordinalCutoff: OrdinalCutoffProjection;
+    cutoff: number | null;
+    protectedTagNumbers: Set<number>;
+    protectedRowIdentities: Set<TIdentity>;
+    status: ProtectionWindowStatus;
+    isProtected: (row: ProtectionWindowRow) => boolean;
+}
+/**
+ * Window mass unit is COALESCE(token_count, 0) only — input_token_count is excluded.
+ * This single shared helper computes the mass contribution of a walked row.
+ */
+export declare function rowWindowMass(row: ProtectionWindowRow): number;
+export declare function getRowKind(row: ProtectionWindowRow): string;
+export declare function getRowTagNumber(row: ProtectionWindowRow): number;
+export declare function getRowIdentity(row: ProtectionWindowRow): number | string;
+export declare function rowKey(row: ProtectionWindowRow): string;
+export declare function compareRowsAscending(a: ProtectionWindowRow, b: ProtectionWindowRow): number;
+/**
+ * Pure canonical protection window walk.
+ *
+ * Traversal: deterministic total order ascending (tag_number, row_identity) walked in REVERSE.
+ * Mass accumulation: COALESCE(token_count, 0) accumulated until sum >= floor.
+ * Stop: tie-group atomic (a whole duplicate-tag_number group is accumulated before testing floor).
+ * Structural minimum: newest min(3, N) tool-kind tags by tag_number descending.
+ * Cutoff: min(mass_cutoff, newest3_cutoff).
+ * Canonical membership: union row set (all tool rows with tag_number >= cutoff).
+ */
+export declare function computeProtectionWindow<TRow extends ProtectionWindowRow = ProtectionWindowRow>(rows: readonly TRow[], floor: number, toolsRatio?: number): ProtectionWindowResult<TRow>;
+/**
+ * Read the snapshotted epoch floor from session_meta.
+ * On defer passes this module reads the snapshot and never recomputes the floor.
+ */
+export declare function readEpochFloorSnapshot(db: Database, sessionId: string): number | null;
+/**
+ * Read only the persisted tool suffix needed for protection. A tag-number group
+ * can span pages, so test the stopping condition only when the next group starts.
+ * Dropped rows still contribute to chronology and mass, just as in the pure walk.
+ */
+export declare function getProtectionWindowForSession(db: Database, sessionId: string, floor?: number | null): ProtectionWindowResult;
+//# sourceMappingURL=protection-window.d.ts.map

package/dist/features/magic-context/protection-window.d.ts.map

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

package/dist/features/magic-context/range-parser.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Parses a range string into a sorted, deduplicated array of integers.
+ *
+ * Supported syntax:
+ * - Single number: "5" → [5]
+ * - Range: "3-5" → [3, 4, 5]
+ * - Comma-separated: "1,2,9" → [1, 2, 9]
+ * - Mixed: "1-5,8,12-15" → [1, 2, 3, 4, 5, 8, 12, 13, 14, 15]
+ *
+ * Tolerant of the `§N§` tag notation the agent sees in the transcript: a model
+ * frequently copies the markers verbatim (e.g. `§302§-§380§`) instead of the bare
+ * numbers. Copied tag handles, prose references (`tag 12`), and dropped
+ * placeholders are normalized before parsing the list and its range endpoints.
+ *
+ * @throws {Error} on empty string, non-numeric input, reversed ranges, or ranges exceeding 1000 elements
+ */
+export declare function parseRangeString(input: string): number[];
+//# sourceMappingURL=range-parser.d.ts.map

package/dist/features/magic-context/range-parser.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"range-parser.d.ts","sourceRoot":"","sources":["../../../src/features/magic-context/range-parser.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,EAAE,CAuDxD"}

package/dist/features/magic-context/reclaim-protection.d.ts

@@ -0,0 +1,13 @@
+/** Number of recent mmc_reduce arcs retained as visible housekeeping exemplars. */
+export declare const CTX_REDUCE_KEEP = 3;
+/**
+ * Return the tag numbers of the newest visible mmc_reduce arcs.
+ *
+ * Callers supply their active tool population so every reclaim lane protects the
+ * same exemplars even when its other eligibility rules differ.
+ */
+export declare function newestCtxReduceTagNumbers(tags: readonly {
+    tagNumber: number;
+    toolName: string | null;
+}[]): Set<number>;
+//# sourceMappingURL=reclaim-protection.d.ts.map

package/dist/features/magic-context/reclaim-protection.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"reclaim-protection.d.ts","sourceRoot":"","sources":["../../../src/features/magic-context/reclaim-protection.ts"],"names":[],"mappings":"AAAA,mFAAmF;AACnF,eAAO,MAAM,eAAe,IAAI,CAAC;AAEjC;;;;;GAKG;AACH,wBAAgB,yBAAyB,CACrC,IAAI,EAAE,SAAS;IAAE,SAAS,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAA;CAAE,EAAE,GAChE,GAAG,CAAC,MAAM,CAAC,CAQb"}

package/dist/features/magic-context/resolve-subagent-fallback.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Fallback detection for `is_subagent` when OpenCode's `session.created` event
+ * has not yet been processed by our event handler.
+ *
+ * Why this exists:
+ *   OpenCode creates a session and returns the ID to the API caller. The
+ *   caller can immediately prompt against that session. Our
+ *   `experimental.chat.system.transform` and `experimental.chat.messages.transform`
+ *   hooks fire during that prompt flow. But the `session.created` event is
+ *   published via `Effect.sync(SyncEvent.run(...))` → `Database.effect(() => ...)`
+ *   → `void publish(result)` in OpenCode's sync/index.ts. Fire-and-forget.
+ *
+ *   So on a fresh child session, the very first transform pass can run BEFORE
+ *   our event handler has written `is_subagent=1` to session_meta.
+ *   `getOrCreateSessionMeta` then returns the default `isSubagent: false`,
+ *   which misclassifies the session as primary for that pass. The plugin
+ *   injects §N§ prefixes, adjunct blocks, and attempts primary-mode gates —
+ *   all of which are wrong for a subagent and can bust Anthropic prompt-cache
+ *   when the correct reduced-mode state kicks in on the next pass.
+ *
+ *   This fallback bridges that gap by reading OpenCode's `session.parent_id`
+ *   directly from its SQLite DB when we first create a session_meta row.
+ */
+/**
+ * Peek at OpenCode's `session` table to determine whether the given session
+ * is a subagent (has a non-empty `parent_id`).
+ *
+ * Returns:
+ *   - `true`  → session row exists with non-empty parent_id → SUBAGENT
+ *   - `false` → session row exists with null/empty parent_id → PRIMARY
+ *   - `null`  → session row doesn't exist yet OR DB read failed → UNKNOWN
+ *
+ * Callers should default to PRIMARY behavior on `null` because the common
+ * case (root sessions, test harness edge cases, DB unavailable) is primary.
+ * But when the row EXISTS and `parent_id` is populated, we can trust it
+ * immediately — OpenCode writes this row synchronously as part of
+ * `Session.create()`, before returning the session ID to the API caller.
+ */
+export declare function resolveIsSubagentFromOpenCodeDb(sessionId: string): boolean | null;
+/** The same creation-time fallback using OC2's authoritative projection, never the retained v1 table. */
+export declare function resolveIsSubagentFromOpenCode2Db(sessionId: string): boolean | null;
+//# sourceMappingURL=resolve-subagent-fallback.d.ts.map

package/dist/features/magic-context/resolve-subagent-fallback.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"resolve-subagent-fallback.d.ts","sourceRoot":"","sources":["../../../src/features/magic-context/resolve-subagent-fallback.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AAYH;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,+BAA+B,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,GAAG,IAAI,CAejF;AAED,yGAAyG;AACzG,wBAAgB,gCAAgC,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,GAAG,IAAI,CAalF"}

package/dist/features/magic-context/scheduler.d.ts

@@ -0,0 +1,20 @@
+import type { ContextUsage, SchedulerDecision, SessionMeta } from "./types";
+export interface Scheduler {
+    shouldExecute(sessionMeta: SessionMeta, contextUsage: ContextUsage, currentTime?: number, sessionId?: string, modelKey?: string, contextLimit?: number): SchedulerDecision;
+}
+interface SchedulerConfig {
+    executeThresholdPercentage: number | {
+        default: number;
+        [modelKey: string]: number;
+    };
+    executeThresholdTokens?: {
+        default?: number;
+        [modelKey: string]: number | undefined;
+    };
+}
+export declare function parseCacheTtl(ttl: string): number;
+export declare function createScheduler(config: SchedulerConfig): Scheduler;
+/** The idle clock is the last served response, not the last prepared request. */
+export declare function computeHardCacheExpired(cacheTtl: string, lastResponseTime: number, now: number, onInvalid?: (error: unknown) => void): boolean;
+export {};
+//# sourceMappingURL=scheduler.d.ts.map

package/dist/features/magic-context/scheduler.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"scheduler.d.ts","sourceRoot":"","sources":["../../../src/features/magic-context/scheduler.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,YAAY,EAAE,iBAAiB,EAAE,WAAW,EAAE,MAAM,SAAS,CAAC;AAW5E,MAAM,WAAW,SAAS;IACtB,aAAa,CACT,WAAW,EAAE,WAAW,EACxB,YAAY,EAAE,YAAY,EAC1B,WAAW,CAAC,EAAE,MAAM,EACpB,SAAS,CAAC,EAAE,MAAM,EAClB,QAAQ,CAAC,EAAE,MAAM,EACjB,YAAY,CAAC,EAAE,MAAM,GACtB,iBAAiB,CAAC;CACxB;AAED,UAAU,eAAe;IACrB,0BAA0B,EAAE,MAAM,GAAG;QAAE,OAAO,EAAE,MAAM,CAAC;QAAC,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,CAAA;KAAE,CAAC;IACrF,sBAAsB,CAAC,EAAE;QAAE,OAAO,CAAC,EAAE,MAAM,CAAC;QAAC,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAAA;KAAE,CAAC;CACzF;AAED,wBAAgB,aAAa,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAuBjD;AAED,wBAAgB,eAAe,CAAC,MAAM,EAAE,eAAe,GAAG,SAAS,CAmElE;AAED,iFAAiF;AACjF,wBAAgB,uBAAuB,CACnC,QAAQ,EAAE,MAAM,EAChB,gBAAgB,EAAE,MAAM,EACxB,GAAG,EAAE,MAAM,EACX,SAAS,CAAC,EAAE,CAAC,KAAK,EAAE,OAAO,KAAK,IAAI,GACrC,OAAO,CAUT"}

package/dist/features/magic-context/schema-fence-probe.d.ts

@@ -0,0 +1,29 @@
+import type { Database } from "../../shared/sqlite";
+export declare const STALE_CHILD_SPAWN_FAILURE = "stale_schema_fence";
+export declare const STALE_CHILD_SPAWN_LATCH_THRESHOLD = 2;
+export interface ChildSpawnFenceFailure {
+    failureClass: typeof STALE_CHILD_SPAWN_FAILURE;
+    reason: "newer_schema" | "read_error";
+    persistedVersion: number;
+    supportedVersion: number;
+    consecutiveFailures: number;
+    totalFailures: number;
+    latched: boolean;
+}
+export type ChildSpawnFenceProbeResult = {
+    allowSpawn: true;
+} | {
+    allowSpawn: false;
+    failure: ChildSpawnFenceFailure;
+    shouldSurface: boolean;
+};
+/**
+ * Probe the schema fence immediately before a child is created. The hot path uses
+ * the process's existing SQLite handle; an already fail-closed main handle has no
+ * handle to query, so its recorded rejection is the authoritative verdict.
+ */
+export declare function probeChildSpawnFence(db: Database | null): ChildSpawnFenceProbeResult;
+export declare function getChildSpawnFenceFailure(): ChildSpawnFenceFailure | null;
+/** Test seam: child-spawn fence state is process-local by design. */
+export declare function __resetChildSpawnFenceProbeForTests(): void;
+//# sourceMappingURL=schema-fence-probe.d.ts.map

package/dist/features/magic-context/schema-fence-probe.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema-fence-probe.d.ts","sourceRoot":"","sources":["../../../src/features/magic-context/schema-fence-probe.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,qBAAqB,CAAC;AAOpD,eAAO,MAAM,yBAAyB,uBAAuB,CAAC;AAC9D,eAAO,MAAM,iCAAiC,IAAI,CAAC;AAEnD,MAAM,WAAW,sBAAsB;IACnC,YAAY,EAAE,OAAO,yBAAyB,CAAC;IAC/C,MAAM,EAAE,cAAc,GAAG,YAAY,CAAC;IACtC,gBAAgB,EAAE,MAAM,CAAC;IACzB,gBAAgB,EAAE,MAAM,CAAC;IACzB,mBAAmB,EAAE,MAAM,CAAC;IAC5B,aAAa,EAAE,MAAM,CAAC;IACtB,OAAO,EAAE,OAAO,CAAC;CACpB;AAkBD,MAAM,MAAM,0BAA0B,GAChC;IAAE,UAAU,EAAE,IAAI,CAAA;CAAE,GACpB;IAAE,UAAU,EAAE,KAAK,CAAC;IAAC,OAAO,EAAE,sBAAsB,CAAC;IAAC,aAAa,EAAE,OAAO,CAAA;CAAE,CAAC;AA0BrF;;;;GAIG;AACH,wBAAgB,oBAAoB,CAAC,EAAE,EAAE,QAAQ,GAAG,IAAI,GAAG,0BAA0B,CA+BpF;AAED,wBAAgB,yBAAyB,IAAI,sBAAsB,GAAG,IAAI,CAEzE;AAED,qEAAqE;AACrE,wBAAgB,mCAAmC,IAAI,IAAI,CAM1D"}