@retaw106/mmc-oc 0.0.0-stage → 1.2.2

package/dist/features/magic-context/storage-subagent-invocations.d.ts

@@ -0,0 +1,62 @@
+import type { HarnessId } from "../../shared/harness";
+import type { Database } from "../../shared/sqlite";
+export type SubagentKind = "historian" | "historian_editor" | "compressor" | "dreamer" | "recomp";
+export type SubagentInvocationStatus = "completed" | "failed" | "aborted" | "timed_out" | "empty";
+export interface SubagentInvocationInput {
+    sessionId: string;
+    harness: HarnessId;
+    subagent: SubagentKind;
+    task?: string | null;
+    providerId?: string | null;
+    modelId?: string | null;
+    startedAt: number;
+    endedAt: number;
+    status: SubagentInvocationStatus;
+    inputTokens: number;
+    outputTokens: number;
+    cacheReadTokens: number;
+    cacheWriteTokens: number;
+    error?: string | null;
+    parentInvocationId?: number | null;
+}
+export interface SubagentInvocationRow {
+    id: number;
+    sessionId: string;
+    harness: HarnessId;
+    subagent: SubagentKind;
+    task: string | null;
+    providerId: string | null;
+    modelId: string | null;
+    startedAt: number;
+    endedAt: number | null;
+    status: SubagentInvocationStatus;
+    inputTokens: number;
+    outputTokens: number;
+    cacheReadTokens: number;
+    cacheWriteTokens: number;
+    error: string | null;
+    parentInvocationId: number | null;
+}
+export interface SubagentTotals {
+    invocations: number;
+    totalInput: number;
+    totalOutput: number;
+    totalCacheRead: number;
+    totalCacheWrite: number;
+}
+export declare function recordSubagentInvocation(db: Database, input: SubagentInvocationInput): number;
+/**
+ * Newest `historian` invocation id for a session (or null if none yet).
+ *
+ * Used to FK-link a `historian_runs` row to the invocation that produced it:
+ * historian runs are serialized per session (compartmentInProgress lock), so the
+ * latest historian invocation recorded between a pre-run baseline and the run's
+ * end is the one for this run.
+ */
+export declare function getLatestHistorianInvocationId(db: Database, sessionId: string): number | null;
+export declare function getSubagentInvocations(db: Database, sessionId: string, opts?: {
+    subagent?: SubagentKind;
+    limit?: number;
+}): SubagentInvocationRow[];
+export declare function getSubagentTotalsBySubagent(db: Database, sessionId: string): Partial<Record<SubagentKind, SubagentTotals>>;
+//# sourceMappingURL=storage-subagent-invocations.d.ts.map

package/dist/features/magic-context/storage-subagent-invocations.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"storage-subagent-invocations.d.ts","sourceRoot":"","sources":["../../../src/features/magic-context/storage-subagent-invocations.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,sBAAsB,CAAC;AACtD,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,qBAAqB,CAAC;AAEpD,MAAM,MAAM,YAAY,GAAG,WAAW,GAAG,kBAAkB,GAAG,YAAY,GAAG,SAAS,GAAG,QAAQ,CAAC;AAElG,MAAM,MAAM,wBAAwB,GAAG,WAAW,GAAG,QAAQ,GAAG,SAAS,GAAG,WAAW,GAAG,OAAO,CAAC;AAElG,MAAM,WAAW,uBAAuB;IACpC,SAAS,EAAE,MAAM,CAAC;IAClB,OAAO,EAAE,SAAS,CAAC;IACnB,QAAQ,EAAE,YAAY,CAAC;IACvB,IAAI,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IACrB,UAAU,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAC3B,OAAO,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IACxB,SAAS,EAAE,MAAM,CAAC;IAClB,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,EAAE,wBAAwB,CAAC;IACjC,WAAW,EAAE,MAAM,CAAC;IACpB,YAAY,EAAE,MAAM,CAAC;IACrB,eAAe,EAAE,MAAM,CAAC;IACxB,gBAAgB,EAAE,MAAM,CAAC;IACzB,KAAK,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IACtB,kBAAkB,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;CACtC;AAED,MAAM,WAAW,qBAAqB;IAClC,EAAE,EAAE,MAAM,CAAC;IACX,SAAS,EAAE,MAAM,CAAC;IAClB,OAAO,EAAE,SAAS,CAAC;IACnB,QAAQ,EAAE,YAAY,CAAC;IACvB,IAAI,EAAE,MAAM,GAAG,IAAI,CAAC;IACpB,UAAU,EAAE,MAAM,GAAG,IAAI,CAAC;IAC1B,OAAO,EAAE,MAAM,GAAG,IAAI,CAAC;IACvB,SAAS,EAAE,MAAM,CAAC;IAClB,OAAO,EAAE,MAAM,GAAG,IAAI,CAAC;IACvB,MAAM,EAAE,wBAAwB,CAAC;IACjC,WAAW,EAAE,MAAM,CAAC;IACpB,YAAY,EAAE,MAAM,CAAC;IACrB,eAAe,EAAE,MAAM,CAAC;IACxB,gBAAgB,EAAE,MAAM,CAAC;IACzB,KAAK,EAAE,MAAM,GAAG,IAAI,CAAC;IACrB,kBAAkB,EAAE,MAAM,GAAG,IAAI,CAAC;CACrC;AAED,MAAM,WAAW,cAAc;IAC3B,WAAW,EAAE,MAAM,CAAC;IACpB,UAAU,EAAE,MAAM,CAAC;IACnB,WAAW,EAAE,MAAM,CAAC;IACpB,cAAc,EAAE,MAAM,CAAC;IACvB,eAAe,EAAE,MAAM,CAAC;CAC3B;AA8CD,wBAAgB,wBAAwB,CAAC,EAAE,EAAE,QAAQ,EAAE,KAAK,EAAE,uBAAuB,GAAG,MAAM,CA4B7F;AAED;;;;;;;GAOG;AACH,wBAAgB,8BAA8B,CAAC,EAAE,EAAE,QAAQ,EAAE,SAAS,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAa7F;AAED,wBAAgB,sBAAsB,CAClC,EAAE,EAAE,QAAQ,EACZ,SAAS,EAAE,MAAM,EACjB,IAAI,GAAE;IAAE,QAAQ,CAAC,EAAE,YAAY,CAAC;IAAC,KAAK,CAAC,EAAE,MAAM,CAAA;CAAO,GACvD,qBAAqB,EAAE,CAoBzB;AAED,wBAAgB,2BAA2B,CACvC,EAAE,EAAE,QAAQ,EACZ,SAAS,EAAE,MAAM,GAClB,OAAO,CAAC,MAAM,CAAC,YAAY,EAAE,cAAc,CAAC,CAAC,CAyB/C"}

package/dist/features/magic-context/storage-tags.d.ts

@@ -0,0 +1,542 @@
+import type { Database } from "../../shared/sqlite";
+import type { TagEntry } from "./types";
+declare module "./types" {
+    interface TagEntry {
+        id?: number;
+        tokenCount?: number | null;
+    }
+}
+export type { TagEntry } from "./types";
+/**
+ * Bump a tag's byte_size when a later occurrence of the same call_id
+ * carries a larger payload. Used by `tagTranscript` to record the
+ * tool-result payload size after the tool-use invocation already
+ * reserved the tag with the args size.
+ *
+ * No-op if newByteSize is not strictly larger than the stored value
+ * (caller should compare in memory and only call when necessary).
+ */
+export declare function updateTagByteSize(db: Database, sessionId: string, tagNumber: number, newByteSize: number): void;
+/**
+ * Per-owning-message token totals for the ACTIVE tags of a session, keyed by
+ * the real message id (not the synthetic content id). Both the sidebar
+ * breakdown and the protected-tail true-raw measurement index into this by the
+ * message ids they already hold (their window / eligible slice), so the result
+ * is window-scoped by construction — it never overcounts a still-active tag
+ * that has been trimmed out of the live window.
+ *
+ * Owner derivation:
+ *   - tool tags: `tool_owner_message_id` (the assistant message that invoked).
+ *   - message/file tags: `message_id` is the content id `${msgId}:pN` /
+ *     `${msgId}:fileN`; the real message id is the prefix before the last
+ *     `:p`/`:file` segment.
+ *
+ * Each entry carries the conversation/toolCall split (reasoning always folds
+ * into conversation, mirroring the live per-part walk) plus `hasNull`: true
+ * when any contributing tag still has a NULL token_count (legacy row written
+ * before the column existed), signalling the caller to tokenize+backfill that
+ * message this pass instead of trusting the stored sum.
+ */
+export interface MessageTokenTotal {
+    conversation: number;
+    toolCall: number;
+    /**
+     * Tool OUTPUT tokens only (the mmc_reduce-droppable payload), excluding tool
+     * input args — this is the "reclaimable" figure the nudge channels gate on,
+     * matching the legacy `computeTailToolTokens` semantics (which summed
+     * `state.output`). `toolCall` = this + input args, for the sidebar bucket.
+     */
+    toolOutput: number;
+    hasNull: boolean;
+}
+/**
+ * Return known message owners in descending persisted tag order. Paging stops
+ * as soon as the requested number of distinct owners is found, so the common
+ * newest-20 lookup does not materialize a long session's complete tag table.
+ * Dropped and compacted rows remain part of the chronology by design.
+ */
+export declare function getRecentTagOwnerMessageIds(db: Database, sessionId: string, maxOwners: number): Set<string>;
+/**
+ * Session-level aggregate of ACTIVE tag token counts — the real live-tail
+ * weight EXCLUDING injected m[0]/m[1] blocks (which are never tagged). This is
+ * the single source for the nudge channels:
+ *   - liveTail   = conversation + toolCall  (real user/assistant + tool I/O)
+ *   - reclaimable = toolOutput              (non-dropped, mmc_reduce-droppable)
+ *   - usable      = executeThresholdTokens − inputTokens + liveTail
+ * `nullCount` > 0 means some active tags are legacy/un-backfilled this pass; the
+ * caller may fall back to the byte-approx path until they converge.
+ */
+export interface ActiveTagTokenAggregate {
+    conversation: number;
+    toolCall: number;
+    toolOutput: number;
+    nullCount: number;
+}
+/**
+ * `protectedCutoff` is the canonical token-window suffix cutoff. Reclaimable
+ * tool output excludes rows at or above it; null applies no threshold.
+ * `conversation`/`toolCall` are not narrowed because protected content remains
+ * part of the live working range.
+ */
+export declare function getActiveTagTokenAggregate(db: Database, sessionId: string, protectedCutoff?: number | null): ActiveTagTokenAggregate;
+export interface ToolReclaimHintTag {
+    tagNumber: number;
+    toolName: string | null;
+}
+export interface AgeReclaimToolTag extends ToolReclaimHintTag {
+    /** Cached output + input tokens; null means the legacy row has no size estimate. */
+    reclaimableTokens: number | null;
+}
+/**
+ * A reclaim hint should point at MEANINGFULLY reclaimable output, not a
+ * 30-token status line or a tiny control-plane call. Tags whose cached token
+ * total is known AND below this are skipped. A tag with NO cached token count
+ * is NOT excluded by the floor (we cannot size it, so we never hide a
+ * potentially-large output).
+ */
+export declare const AGE_RECLAIM_MIN_TOKENS = 250;
+export declare function getOldestActiveUnprotectedToolTags(db: Database, sessionId: string, protectedTagNumbers?: ReadonlySet<number>, limit?: number): ToolReclaimHintTag[];
+/**
+ * Return age-reclaim candidates with the same persisted token estimate used by reclaim hints.
+ * The newest mmc_reduce exemplars are omitted before the watermark/value checks in the caller.
+ * Legacy rows with neither token column populated remain eligible for fail-safe reclaim.
+ */
+export declare function getActiveToolTagsForAgeReclaim(db: Database, sessionId: string): AgeReclaimToolTag[];
+/**
+ * Upper bound on the historian's true-raw ELIGIBLE tokens for the cheap
+ * trigger pre-gate. Sums `active` AND `dropped` tags: a mmc_reduce/emergency
+ * drop removes a tool output from the wire (and the active set) but its raw
+ * content stays in OpenCode's DB and still counts toward the historian's
+ * chunk size — an active-only bound undercounts after drops and wrongly
+ * suppresses real tail-size triggers. `compacted` tags are excluded: they sit
+ * before the last compartment boundary by construction, so they can't be in
+ * the eligible window (including them would only make the gate uselessly
+ * conservative). nullCount spans the same active+dropped set — the bound is
+ * only trustworthy when every contributing row has a cached token count.
+ */
+export declare function getTriggerTagTokenUpperBound(db: Database, sessionId: string, floor?: number): {
+    bound: number;
+    nullCount: number;
+};
+export declare function getActiveTagTokenTotalsByMessage(db: Database, sessionId: string, messageIds?: readonly string[]): Map<string, MessageTokenTotal>;
+/**
+ * Bump a tag's input_byte_size when a tool_use occurrence is seen
+ * after the result occurrence (rare in practice; supports both
+ * orderings).
+ */
+export declare function updateTagInputByteSize(db: Database, sessionId: string, tagNumber: number, newInputByteSize: number): void;
+/**
+ * Bump a tag's token_count when a later occurrence of the same call_id carries a
+ * larger output payload — the token mirror of `updateTagByteSize`, called from
+ * the same site so the cached token count tracks the grown tool result.
+ */
+export declare function updateTagTokenCount(db: Database, sessionId: string, tagNumber: number, newTokenCount: number): void;
+export interface PersistedToolTagAccounting {
+    byteSize: number;
+    tokenCount: number | null;
+    inputByteSize: number;
+    inputTokenCount: number | null;
+}
+/** Read the authoritative accounting after an exceptional same-pass owner adoption. */
+export declare function getPersistedToolTagAccounting(db: Database, sessionId: string, tagNumber: number): PersistedToolTagAccounting | null;
+/**
+ * Flat per-message ORIGINAL token map for the protected-tail boundary, keyed by
+ * real message id. Sums every tag's stored token weight (output + input +
+ * reasoning) for a message REGARDLESS of drop status, because the boundary
+ * measures true-raw tokens — the original content the historian re-reads to
+ * compact, which lives in opencode.db even when the wire shows a `[dropped]`
+ * sentinel. (An active-only sum would undercount the eligible range whenever a
+ * tool output had been mmc_reduce-dropped in the live tail.)
+ *
+ * A message with ANY tag still carrying a NULL token_count (legacy, not yet
+ * backfilled) is reported in `nullMessageIds` and omitted from `totals`, so the
+ * boundary live-tokenizes it this pass and converges to the stored path after
+ * the tagger backfills. Pre-boundary (`compacted`) messages cancel out of the
+ * boundary's prefix-difference math, so including them here is harmless.
+ */
+export declare function getAllStatusTagTokenTotalsFlat(db: Database, sessionId: string, floor?: number, calibration?: {
+    proseRatio: number;
+    toolsRatio: number;
+}, options?: {
+    excludeToolTags?: boolean;
+}): {
+    totals: Map<string, number>;
+    nullMessageIds: Set<string>;
+};
+/** Bump a tag's input_token_count — the token mirror of `updateTagInputByteSize`. */
+export declare function updateTagInputTokenCount(db: Database, sessionId: string, tagNumber: number, newInputTokenCount: number): void;
+/**
+ * True when a tag row still has a NULL token_count — i.e. it was written before
+ * the token columns existed (legacy) and needs a one-time backfill. Used by the
+ * tagger's DB-existing (post-restart cold) path to decide whether to invoke the
+ * tokenizer thunk; populated rows skip it so a restart never re-tokenizes.
+ */
+export declare function tagTokenCountIsNull(db: Database, sessionId: string, tagNumber: number): boolean;
+/**
+ * One-time backfill of a legacy tag's token columns. Guarded by
+ * `token_count IS NULL` so it is idempotent and a no-op once populated (a later
+ * pass / restart cannot clobber a real count). Mirrors the byte columns set at
+ * insert time.
+ */
+export declare function backfillTagTokenCounts(db: Database, sessionId: string, tagNumber: number, counts: TagTokenCounts): void;
+/**
+ * Per-tag token counts (real Claude tokenizer), computed once at insert time.
+ * `null` fields mean "not measured" (legacy callers / rows predating the
+ * columns); readers treat NULL as a fall-back-per-call signal.
+ */
+export interface TagTokenCounts {
+    tokenCount: number | null;
+    inputTokenCount: number | null;
+    reasoningTokenCount: number | null;
+}
+export declare function insertTag(db: Database, sessionId: string, messageId: string, type: TagEntry["type"], byteSize: number, tagNumber: number, reasoningByteSize?: number, toolName?: string | null, inputByteSize?: number, toolOwnerMessageId?: string | null, entryFingerprint?: string | null, tokenCounts?: TagTokenCounts | null): number;
+export declare function updateTagStatus(db: Database, sessionId: string, tagId: number, status: TagEntry["status"]): void;
+export interface InertWhitespaceAssistantTag {
+    tagNumber: number;
+    contentId: string;
+}
+export declare function markWhitespaceAssistantTagInert(db: Database, sessionId: string, tagNumber: number, contentId: string): void;
+/** Load legacy whitespace tags for cache-stable prefix replay; these rows are never active. */
+export declare function getInertWhitespaceAssistantTags(db: Database, sessionId: string, messageIds?: readonly string[]): InertWhitespaceAssistantTag[];
+export declare function updateTagDropMode(db: Database, sessionId: string, tagNumber: number, dropMode: TagEntry["dropMode"]): void;
+/**
+ * Set the caveman compression depth for a tag.
+ *
+ * Only message tags are expected to receive non-zero depth; callers enforce
+ * that. Persisted so later transform passes and restarts can resume without
+ * re-compressing text that already matches its target age-tier depth.
+ */
+export declare function updateCavemanDepth(db: Database, sessionId: string, tagNumber: number, depth: number): void;
+export declare function updateTagMessageId(db: Database, sessionId: string, tagId: number, messageId: string): void;
+/** Return whether this session has any message tag bound to a fallback Pi id. */
+export declare function hasPiFallbackMessageTags(db: Database, sessionId: string): boolean;
+/**
+ * Pi fallback-tag adoption lookup. Find the message-text tag(s) created under a
+ * `pi-msg-*` fallback id for a given (session, entry_fingerprint), so the next
+ * pass can migrate them onto the message's real SessionEntry id. Returns the
+ * candidate rows (tag_number + current message_id) for the caller to apply the
+ * per-part uniqueness guard and race-safe migrate. Scoped to `type='message'`
+ * and the fallback-id shape so a real-id row is never re-adopted.
+ */
+export declare function findAdoptableFallbackTags(db: Database, sessionId: string, entryFingerprint: string): Array<{
+    tagNumber: number;
+    messageId: string;
+}>;
+/**
+ * Race-safe migrate of a tag's `message_id` from a known old (fallback) value to
+ * a new (real) value. The old value in the WHERE clause is the concurrency fence
+ * (mirrors `adoptNullOwnerToolTag`'s NULL guard): if a sibling process already
+ * migrated or re-keyed the row, `changes === 0` and the caller skips. Trigger
+ * writes may increase a positive count, so only zero versus nonzero is meaningful.
+ * Returns true iff exactly this migration applied.
+ */
+export declare function adoptFallbackTagMessageId(db: Database, sessionId: string, tagNumber: number, oldFallbackMessageId: string, newRealMessageId: string): boolean;
+export interface PiFallbackToolOwnerTag {
+    tagNumber: number;
+    callId: string;
+    toolOwnerMessageId: string;
+    status: string;
+}
+export type PiFallbackTagAdoptionResult = {
+    action: "skipped";
+} | {
+    action: "rekeyed";
+    tagNumber: number;
+} | {
+    action: "folded";
+    tagNumber: number;
+    deletedTagNumbers: number[];
+};
+/** One message whose host projection now exposes fewer parts than it did when its tags were minted. */
+export interface ShrunkPartMessage {
+    messageId: string;
+    /** Number of parts the RUNNING host projection gives this message. */
+    partCount: number;
+}
+export interface MergedPartTagFoldResult {
+    /** Tags deleted because their part index no longer exists on the wire. */
+    foldedTagNumbers: number[];
+    /** Tags whose content id was moved down to `:p0` because no `:p0` tag existed. */
+    rekeyedTagNumbers: number[];
+    /** Queued `mmc_reduce` drops removed because the fold would have widened their target. */
+    discardedDropTagNumbers: number[];
+}
+/**
+ * Re-seat message part tags after the host changed how many parts a message has.
+ *
+ * A message tag is keyed by the content id `<messageId>:p<index>`, where the
+ * index is the message's own part position. When the host rewrites a multi-part
+ * message into a single joined text part, every tag above the surviving index
+ * loses its target: the text it was minted for is now part of the first part's
+ * text. Those tags are folded into the first part's tag through the same
+ * merge/retarget path a duplicate tag takes, so the §N§ already shown to the
+ * model keeps its meaning and nothing is renumbered.
+ *
+ * A queued `mmc_reduce` drop is NOT carried across the fold unless every part
+ * tag of that message carries one. The user authorised removing one fragment;
+ * after the merge that same operation would remove the whole joined text, which
+ * is a larger deletion than the one they asked for. Those queue entries are
+ * removed and reported to the caller instead.
+ *
+ * An executed drop follows the same rule: a folded tag's `dropped` status is
+ * not copied onto the surviving tag, because the survivor now stands for the
+ * whole joined text. When every fragment was dropped the survivor is one of
+ * them and is already `dropped`, so the joined text stays hidden.
+ */
+export declare function foldShrunkPartTags(db: Database, sessionId: string, messages: readonly ShrunkPartMessage[]): MergedPartTagFoldResult;
+export declare function hasPiFallbackToolOwnerTags(db: Database, sessionId: string): boolean;
+export declare function findPiFallbackToolOwnerTags(db: Database, sessionId: string): PiFallbackToolOwnerTag[];
+export declare function adoptPiFallbackToolOwnerTag(db: Database, sessionId: string, tagNumber: number, callId: string, oldOwnerMessageId: string, newOwnerMessageId: string): PiFallbackTagAdoptionResult;
+export declare function adoptPiFallbackMessageTag(db: Database, sessionId: string, tagNumber: number, oldFallbackMessageId: string, newRealMessageId: string): PiFallbackTagAdoptionResult;
+/**
+ * Retire tags minted from rows removed by an in-memory compartment trim. The
+ * rows never reach the served tail, so leaving them active would leak into
+ * reclaim hints and hygiene accounting. Repeated calls are idempotent.
+ */
+export declare function markTagsCompactedByMessageIds(db: Database, sessionId: string, messageIds: Iterable<string>): number;
+/**
+ * Delete every tag whose source content lives on `messageId`. This is
+ * the `message.removed` event handler's primary cleanup path.
+ *
+ * What gets deleted:
+ *   - Message tags: `messageId == <removed-msg-id>` (text parts).
+ *   - File tags: `messageId LIKE <removed-msg-id>:p%` /
+ *     `<removed-msg-id>:file%`.
+ *   - Content-derived text tags (Pi): `<removed-msg-id>:mc-text-v1:%`.
+ *   - Tool tags owned by the removed message:
+ *     `tool_owner_message_id == <removed-msg-id>` (v3.3.1 Layer C).
+ *
+ * Pre-v10 semantics: tool tags used `messageId = callId`, so a removed
+ * assistant message would not match any tool tag's `messageId` field
+ * (the message id was never written there for tool tags). The fix:
+ * include tool tags by composite-owner identity so an assistant
+ * message removal correctly cascades to the tool tags it hosted.
+ *
+ * Returns the tag numbers that were deleted (used by the event handler
+ * to re-anchor reasoning watermarks and audit logs).
+ */
+export declare function deleteTagsByMessageId(db: Database, sessionId: string, messageId: string): number[];
+export declare function getMaxTagNumberBySession(db: Database, sessionId: string): number;
+/**
+ * Look up the tag_number assigned to a specific (session_id, message_id).
+ *
+ * Used by the tagger's recovery path to bind an existing DB-assigned tag back
+ * into the in-memory assignment map without bumping the counter past the DB's
+ * actual max. Returns null when no tag exists for that message yet.
+ */
+export declare function getTagNumberByMessageId(db: Database, sessionId: string, messageId: string): number | null;
+/** Look up a live tag assignment without reviving a retired whitespace framing row. */
+export declare function getAssignableTagNumberByMessageId(db: Database, sessionId: string, messageId: string): number | null;
+/**
+ * Lowest `tag_number` among the message/file content-ids of a single raw
+ * message id, used to derive the tagger load-scoping floor from the first
+ * message(s) in the live wire.
+ *
+ * message/file tags key on the synthetic content-id `${rawId}:p${n}` /
+ * `${rawId}:file${n}`. The half-open range `[rawId+':', rawId+';')` captures
+ * exactly one rawId's content-ids: ':' (0x3A) is the field separator and ';'
+ * (0x3B) is its immediate successor, so a different rawId (even a prefix like
+ * `msg_abc` vs `msg_abcd`) diverges before the ':' and sorts outside the
+ * range. This is a sargable index range scan on idx_tags_session_message_id
+ * (no LIKE, no wildcard escaping). Tool tags are NOT matched (their message_id
+ * is the callId, not `${rawId}:…`) — intentional: the floor bounds message/file
+ * tags; tool straddle is handled separately.
+ *
+ * Returns null when the rawId has no message/file tag yet (untagged synthetic
+ * leader) or, defensively, when the rawId itself contains ':' (which would
+ * break the delimiter proof — never true for OpenCode `msg_*` ids).
+ */
+export declare function getMinMessageTagNumberForRawId(db: Database, sessionId: string, rawId: string): number | null;
+export declare const TAGGER_FLOOR_SCAN_MESSAGES = 8;
+export declare const TAGGER_FLOOR_MAX_PROBES = 64;
+export declare const TAGGER_FLOOR_SAFETY_MARGIN = 256;
+export declare const TAGGER_FLOOR_PER_SKIP_MARGIN = 64;
+/**
+ * Derive the tagger/scan load-scoping floor from the leading wire message ids:
+ * roughly the minimum message/file tag number across the leading messages,
+ * minus a safety margin (clamped to 0). Shared by the tagger's `initFromDb` and
+ * the compartment trigger's tag scans so both scope to the same live-wire range.
+ * Returns 0 when nothing resolves → callers fall back to the full-session scan.
+ *
+ * `getMinMessageTagNumberForRawId` matches ONLY a message's `:p`/`:file` tags,
+ * never its tool tags (those key on the callId). So the wire head — which after
+ * a compaction marker is frequently a run of tool-only assistant turns and/or
+ * tagless ghost/synthetic leaders — returns all-NULL. The old code capped at the
+ * first 8 ID-BEARING probes and took their MIN, so such a head exhausted the
+ * budget on NULLs → Infinity → floor 0 → the full ~100k-tag scan we are trying
+ * to avoid (the live ~66ms compartmentTrigger oscillation).
+ *
+ * Fix: keep probing PAST NULL leaders until SCAN_HITS messages resolve (bounded
+ * by MAX_PROBES). A skipped tool-only leader's tool tags sit just BELOW the
+ * first `:p` tag we land on, so we widen the margin by PER_SKIP_MARGIN for every
+ * leader skipped before the first hit — the floor still only ever errs LOWER
+ * (loads a few extra tags), never higher (never drops a live-wire tag).
+ */
+export declare function deriveTagLoadFloor(db: Database, sessionId: string, rawIds: Iterable<string | null | undefined>): number;
+export declare const TAG_SELECT_COLUMNS = "id, message_id, type, status, drop_mode, tool_name, input_byte_size, byte_size, reasoning_byte_size, session_id, tag_number, caveman_depth, tool_owner_message_id, token_count";
+export declare function getTagsBySession(db: Database, sessionId: string): TagEntry[];
+/**
+ * Return only the tags whose status is 'active' for this session.
+ *
+ * Backed by the partial index `idx_tags_active_session_tag_number` so the
+ * scan touches only active rows instead of every tag in the session.
+ *
+ * Use this in: heuristic cleanup, nudger, caveman replay scope, anywhere
+ * that filters `tags.filter(t => t.status === "active")` on the result of
+ * `getTagsBySession`.
+ *
+ * The returned shape matches `TagEntry` exactly so callers can swap with
+ * no behavior change beyond seeing fewer (active-only) rows.
+ */
+export declare function getActiveTagsBySession(db: Database, sessionId: string): TagEntry[];
+/**
+ * Attribution rows for final rendered-tail accounting. Active, non-protected
+ * rows identify reclaimable token mass (U). Legacy tool rows with no owner are
+ * included regardless of status so duplicate call IDs remain visible and the
+ * orphan resolver can reject ambiguous matches.
+ */
+export declare function getTailHygieneTags(db: Database, sessionId: string): TagEntry[];
+/**
+ * Return only dropped tags for a session. The partial dropped-tag index avoids
+ * loading active and compacted history when a force seed only needs drop state.
+ */
+export declare function getDroppedTagsBySession(db: Database, sessionId: string, scope?: {
+    ownerIds: readonly string[];
+    messageAddresses: readonly string[];
+}): TagEntry[];
+/**
+ * Return the tags whose tag_number is in `tagNumbers` for this session.
+ *
+ * Used by `applyFlushedStatuses` (and similar replay loops) to fetch the
+ * subset of tags that match the current pass's visible target set rather
+ * than scanning every tag in the session.
+ *
+ * The IN-list is built dynamically because SQLite caches prepared
+ * statements per query string, but we still get prepared-statement reuse
+ * for any given list size that happens twice in a row (which is the
+ * common case during long sessions).
+ *
+ * Returns an empty array when `tagNumbers` is empty (avoids generating
+ * `IN ()` which is an SQL syntax error).
+ */
+export declare function getTagsForPendingOperations(db: Database, sessionId: string, pendingTagNumbers: readonly number[], protectedCount: number, recentToolWindow: number): TagEntry[];
+export declare function getTagsByNumbers(db: Database, sessionId: string, tagNumbers: readonly number[]): TagEntry[];
+/** Return only dropped tags whose numbers are visible replay targets. */
+export declare function getDroppedTagsByNumbers(db: Database, sessionId: string, tagNumbers: readonly number[]): TagEntry[];
+/**
+ * Return the maximum tag_number among tags whose status is 'dropped' for
+ * this session, or 0 if no dropped tags exist.
+ *
+ * Replaces the full-array iteration `for (tag of tags) if (dropped &&
+ * tag_number > max) max = tag_number` with a single SQL aggregate.
+ * Backed by the partial index `idx_tags_dropped_session_tag_number` so
+ * SQLite resolves the MAX with a backward index seek (O(log N)).
+ */
+export declare function getMaxDroppedTagNumber(db: Database, sessionId: string): number;
+export declare function getTagById(db: Database, sessionId: string, tagId: number): TagEntry | null;
+export declare function getTopNBySize(db: Database, sessionId: string, n: number): TagEntry[];
+/**
+ * Look up the tag_number for a specific composite tool identity.
+ *
+ * Returns null when no tag exists for `(sessionId, callId, ownerMsgId)`.
+ * This is the fast path for the runtime tagger after a tagger restart
+ * or cache eviction.
+ */
+export declare function getToolTagNumberByOwner(db: Database, sessionId: string, callId: string, ownerMsgId: string): number | null;
+/**
+ * Find a NULL-owner tool tag row for `(sessionId, callId)`.
+ *
+ * Used by the lazy-adoption fast path: when the runtime tagger sees a
+ * tool with composite key `(ownerMsgId, callId)` that has no
+ * corresponding row in `assignments`, but the underlying callId already
+ * exists in DB with NULL owner (legacy pre-v10 row), we want to adopt
+ * the orphan rather than allocate a fresh tag. This preserves
+ * cache-stable tag numbers across the v9 → v10 upgrade.
+ *
+ * Returns the lowest-numbered NULL-owner row deterministically. The
+ * caller is expected to follow up with `adoptNullOwnerToolTag` to
+ * atomically claim ownership; if that returns false, another writer
+ * adopted first and the caller must re-check the composite-key fast
+ * path or allocate a fresh tag.
+ */
+export declare function getNullOwnerToolTag(db: Database, sessionId: string, callId: string): {
+    id: number;
+    tagNumber: number;
+} | null;
+/**
+ * Atomically adopt a NULL-owner tool tag row by setting
+ * `tool_owner_message_id = ownerMsgId`. Returns true if exactly one
+ * row was updated (we won the race), false if zero (someone else
+ * adopted between our SELECT and UPDATE).
+ *
+ * The NULL guard makes this concurrent-safe with both the backfill
+ * pass and concurrent runtime adoptions in other plugin processes. The
+ * transaction verifies the owner value directly because trigger writes make
+ * the statement's numeric change count unsuitable as a claim result.
+ */
+export declare function adoptNullOwnerToolTag(db: Database, rowId: number, ownerMsgId: string): boolean;
+/**
+ * Returns the candidate tool-tag owner ids for `(sessionId, callId)` —
+ * every tag with a non-NULL owner. Used by the result-only-window
+ * fallback in `tag-messages.ts`: the caller resolves wall-clock times
+ * for every candidate against the OpenCode DB (via
+ * `getMessageTimesFromOpenCodeDb`) and picks the most recent one whose
+ * `time_created` precedes the current result message.
+ *
+ * The picking logic lives in the caller because resolving message times
+ * requires the OpenCode read-only DB handle, which lives in the hooks
+ * tree. Keeping that import one-way (hooks → features) avoids what
+ * would otherwise be a cycle through the storage barrel.
+ *
+ * Returns an empty array when no candidates exist; the caller falls back
+ * to `messageId` (the result's own id) in that case so the runtime
+ * still allocates a stable composite key.
+ */
+export declare function getCandidateToolOwners(db: Database, sessionId: string, callId: string): string[];
+/**
+ * Pick the most recent (by OpenCode `time_created`) candidate owner
+ * whose message strictly precedes `currentMessageId`. Tie-break on
+ * lexicographic id, matching the legacy single-statement ordering
+ * (`ORDER BY time_created DESC, id DESC` limited to rows where
+ * `time_created < currentTime`).
+ *
+ * Returns null when:
+ *   - The candidate list is empty
+ *   - `currentMessageId` is not present in `times`
+ *   - No candidate predates `currentMessageId` in OC time
+ *
+ * This helper is independent of any DB handle — the caller resolves the
+ * `times` map (typically via `getMessageTimesFromOpenCodeDb`) and passes
+ * it in. Splitting the lookup from the picking keeps `storage-tags.ts`
+ * free of any OpenCode-DB import.
+ */
+export declare function pickNearestPriorOwner(candidates: readonly string[], currentMessageId: string, times: ReadonlyMap<string, number>): string | null;
+/**
+ * Legacy alias kept for the rare runtime call site that hasn't been
+ * migrated to the split lookup-then-pick form. Always returns null
+ * (no message-time data available without a DB handle the function
+ * itself can't reach). New call sites should use `getCandidateToolOwners`
+ * + `getMessageTimesFromOpenCodeDb` + `pickNearestPriorOwner` directly.
+ *
+ * Why we keep this name: the v3.3.1 plan documents this as the public
+ * entry point for the result-only-window fallback. Removing it would
+ * require touching `.alfonso/plans/tag-owner-fix-plan.md` and migrating
+ * the test fixtures that exercise it. Leaving the symbol present with
+ * a noop body keeps existing test scaffolds working while the actual
+ * pick happens in the hooks-tree caller.
+ */
+export declare function getPersistedToolOwnerNearestPrior(_db: Database, _sessionId: string, _callId: string, _currentMessageId: string): string | null;
+/**
+ * Delete every tool tag owned by `ownerMsgId` in the session. Used by
+ * `message.removed` cleanup to scope the deletion correctly: pre-v10
+ * a removed assistant message would `deleteTagsByMessageId(messageId)`
+ * which only matched `message_id = messageId` (the contentId for text
+ * parts), missing tool tags whose `message_id` is the callID. Post-v10
+ * the owner column gives us the right scope.
+ *
+ * Returns the number of rows deleted. NULL-owner legacy rows are not
+ * matched by this helper — they remain reachable via `message_id`-only
+ * deletion paths until adopted or backfilled.
+ */
+export declare function deleteToolTagsByOwner(db: Database, sessionId: string, ownerMsgId: string): number;
+//# sourceMappingURL=storage-tags.d.ts.map

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

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

package/dist/features/magic-context/storage-unavailable-reason.d.ts

@@ -0,0 +1,17 @@
+import type { FailClosedReason } from "./fail-closed-block";
+/**
+ * Explain why the most recent `openDatabase`/`openDatabaseAsync` call in this
+ * process left no usable storage, as the structured reason every host formats
+ * with `formatFailClosedBlockingMessage`.
+ *
+ * The open functions return `null` for two deliberate refusals and record the
+ * detail in module state: a migration refused because another live host may
+ * still run an older build (with the blocking processes), and a database newer
+ * than this build. Anything else (an open that threw, or a handle that is not
+ * durable) is a plain storage failure described by `fallbackCause`, which the
+ * caller takes from the thrown error or the handle's persistence error.
+ *
+ * Call it right after the failed open: the next open clears the recorded state.
+ */
+export declare function describeStorageUnavailability(fallbackCause: string): FailClosedReason;
+//# sourceMappingURL=storage-unavailable-reason.d.ts.map

package/dist/features/magic-context/storage-unavailable-reason.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"storage-unavailable-reason.d.ts","sourceRoot":"","sources":["../../../src/features/magic-context/storage-unavailable-reason.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,qBAAqB,CAAC;AAG5D;;;;;;;;;;;;;GAaG;AACH,wBAAgB,6BAA6B,CAAC,aAAa,EAAE,MAAM,GAAG,gBAAgB,CAyBrF"}