@retaw106/mmc-oc 0.0.0-stage → 1.2.2

package/dist/features/magic-context/storage-v22-backfill-failures.d.ts

@@ -0,0 +1,26 @@
+import type { Database } from "../../shared/sqlite";
+export type V22BackfillErrorClass = "not_git_repo" | "git_missing" | "git_timeout" | "permission_denied" | "unknown";
+type RecordableV22BackfillErrorClass = V22BackfillErrorClass | "dubious_ownership";
+export interface V22BackfillFailureRow {
+    id: number;
+    tableName: string;
+    rowId: number;
+    rawProjectPath: string;
+    errorClass: V22BackfillErrorClass;
+    errorMessage: string | null;
+    failedAt: number;
+}
+export declare function recordV22BackfillFailure(db: Database, input: {
+    tableName: string;
+    rowId: number;
+    rawProjectPath: string;
+    errorClass: RecordableV22BackfillErrorClass;
+    errorMessage?: string | null;
+    failedAt?: number;
+}): V22BackfillFailureRow;
+export declare function getV22BackfillFailure(db: Database, tableName: string, rowId: number): V22BackfillFailureRow | null;
+export declare function listV22BackfillFailures(db: Database): V22BackfillFailureRow[];
+export declare function deleteV22BackfillFailure(db: Database, tableName: string, rowId: number): boolean;
+export declare function clearV22BackfillFailures(db: Database): number;
+export {};
+//# sourceMappingURL=storage-v22-backfill-failures.d.ts.map

package/dist/features/magic-context/storage-v22-backfill-failures.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"storage-v22-backfill-failures.d.ts","sourceRoot":"","sources":["../../../src/features/magic-context/storage-v22-backfill-failures.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,qBAAqB,CAAC;AAEpD,MAAM,MAAM,qBAAqB,GAC3B,cAAc,GACd,aAAa,GACb,aAAa,GACb,mBAAmB,GACnB,SAAS,CAAC;AAEhB,KAAK,+BAA+B,GAAG,qBAAqB,GAAG,mBAAmB,CAAC;AAUnF,MAAM,WAAW,qBAAqB;IAClC,EAAE,EAAE,MAAM,CAAC;IACX,SAAS,EAAE,MAAM,CAAC;IAClB,KAAK,EAAE,MAAM,CAAC;IACd,cAAc,EAAE,MAAM,CAAC;IACvB,UAAU,EAAE,qBAAqB,CAAC;IAClC,YAAY,EAAE,MAAM,GAAG,IAAI,CAAC;IAC5B,QAAQ,EAAE,MAAM,CAAC;CACpB;AAsCD,wBAAgB,wBAAwB,CACpC,EAAE,EAAE,QAAQ,EACZ,KAAK,EAAE;IACH,SAAS,EAAE,MAAM,CAAC;IAClB,KAAK,EAAE,MAAM,CAAC;IACd,cAAc,EAAE,MAAM,CAAC;IACvB,UAAU,EAAE,+BAA+B,CAAC;IAC5C,YAAY,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAC7B,QAAQ,CAAC,EAAE,MAAM,CAAC;CACrB,GACF,qBAAqB,CA0BvB;AAED,wBAAgB,qBAAqB,CACjC,EAAE,EAAE,QAAQ,EACZ,SAAS,EAAE,MAAM,EACjB,KAAK,EAAE,MAAM,GACd,qBAAqB,GAAG,IAAI,CAS9B;AAED,wBAAgB,uBAAuB,CAAC,EAAE,EAAE,QAAQ,GAAG,qBAAqB,EAAE,CAS7E;AAED,wBAAgB,wBAAwB,CAAC,EAAE,EAAE,QAAQ,EAAE,SAAS,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,OAAO,CAKhG;AAED,wBAAgB,wBAAwB,CAAC,EAAE,EAAE,QAAQ,GAAG,MAAM,CAG7D"}

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

@@ -0,0 +1,23 @@
+export { buildCompartmentBlock, escapeXmlAttr, escapeXmlContent, getCompartments, getSessionFacts, replaceAllCompartmentState, replaceAllCompartmentStateAndBumpDepth, type SessionFact, } from "./compartment-storage";
+export { clearCompressionDepth, getAverageCompressionDepth, getMaxCompressionDepth, incrementCompressionDepth, } from "./compression-depth-storage";
+export { type AuthorityManagedMarker, ensureContextStoreUuid, getAuthorityManagedMarker, getContextStoreUuid, installAuthorityManagedMarker, listAuthorityManagedMarkers, removeAuthorityManagedMarker, } from "./context-authority";
+export { clearIndexedMessages, deleteIndexedMessage, } from "./message-index";
+export { runMigrations } from "./migrations";
+export { normalizeStoredProjectPath, ProjectIdentityError, type ProjectIdentityErrorClass, resolveProjectIdentity, resolveProjectIdentityStrict, storedPathBelongsToIdentity, } from "./project-identity";
+export { type CloneCompartmentRow, type CloneSessionStateFilter, type CloneTagRow, type CopySessionStateForCloneResult, copySessionStateForClone, } from "./storage-clone";
+export { applySqliteTuningPragmas, type ContextDatabase, closeDatabase, enforceSchemaFence, FORK_MIGRATION_VERSION_FLOOR, getDatabasePath, getDatabasePersistenceError, getPersistedSchemaVersion, initializeDatabase, isDatabasePersisted, LATEST_SUPPORTED_VERSION, type OpenDatabaseOptions, openDatabase, runSqliteOptimize, schemaVersionIsSupported, setSqlitePragmaConfig, } from "./storage-db";
+export { deleteIdentityRekeyMap, getIdentityRekeyMap, type IdentityRekeyMapRow, listIdentityRekeyMaps, upsertIdentityRekeyMap, } from "./storage-identity-rekey-map";
+export { clearM0MutationsForSession, deleteM0Mutation, getM0Mutation, getM0MutationsAfterId, getM0MutationsBySession, getMaxM0MutationId, type M0MutationLogRow, type M0MutationType, queueM0Mutation, queueM0Mutation as appendM0Mutation, } from "./storage-m0-mutation-log";
+export { getMaxMemoryMutationId, getMaxMemoryMutationIdForProjects, getMemoryMutation, getMemoryMutationsForRender, getMemoryMutationsForRenderByProjects, MEMORY_VISIBILITY_MUTATION_CATEGORY, type MemoryMutationLogRow, type MemoryMutationType, queueMemoryMutation, } from "./storage-memory-mutation-log";
+export { type AcquireWrapupResult, type AppendAutoSearchHintOutcome, type AutoSearchHintDecision, acquireWrapupInProgress, addProcessedImageStrippedIds, addStaleReduceStrippedIds, advanceToolReclaimWatermark, appendAutoSearchHintDecision, applyStrippedPlaceholderDelta, armThinkingBindingRecovery, type Channel2NudgeState, captureChannel1PostReduceGraceBaseline, casChannel2NudgeClaim, casChannel2NudgeState, claimChannel2NudgeState, clearCachedM0, clearCachedM0M1, clearDetectedContextLimit, clearEmergencyDrainLatch, clearEmergencyRecovery, clearHistorianDrainFailure, clearHistorianFailureState, clearPendingCompactionMarkerStateIf, clearPendingPiCompactionMarkerStateIf, clearPersistedReasoningWatermark, clearPersistedTodoSyntheticAnchor, clearSession, clearThinkingBindingRecoveryIf, DRAIN_WINDOW_MS, describeProtectedTailDrainBudgetSkip, getAutoSearchHintDecisions, getChannel1NudgeState, getChannel2NudgeClaim, getChannel2NudgeClaimedAt, getChannel2NudgeState, getHiddenSeamPlaceholderIds, getHistorianFailureState, getLastNudgeUndropped, getOrCreateSessionMeta, getOverflowState, getPendingCompactionMarkerState, getPendingPiCompactionMarkerState, getPersistedReasoningWatermark, getPersistedTodoPermissionDenied, getPersistedTodoSyntheticAnchor, getProcessedImageStrippedIds, getSessionsWithPendingMarker, getSessionsWithPendingPiMarker, getSessionWorkMetrics, getStaleReduceStrippedIds, getStrippedPlaceholderIds, getThinkingBindingRecoveryTarget, getWrapupInProgressState, incrementHistorianFailure, isWrapupInProgress, loadPersistedUsage, loadProtectedTailMeta, MAX_STRIPPED_PLACEHOLDER_IDS, markChannel1PostReduceGracePending, markProtectedTailPolicyV3Seeded, markSessionCleanupPending, type PendingCompactionMarker, type PendingPiCompactionMarker, type PersistCachedM0Payload, type PersistedChannel1NudgeLevel, type PersistedChannel1NudgeState, type PersistedOverflowState, type PersistedTodoSyntheticAnchor, type PersistedUsageState, type ProtectedTailDrainBudgetState, type ProtectedTailDrainReservation, type ProtectedTailDrainReserveResult, type ProtectedTailMeta, type ProtectedTailSeedResult, persistCachedM0, protectedTailWindowBudget, pruneAutoSearchHintDecisions, recordDetectedContextLimit, recordHistorianDrainFailure, recordOverflowDetected, recordProtectedTailNoEligibleHead, recordProtectedTailPublicationFloor, releaseWrapupInProgress, removeAutoSearchHintDecisionByMessageId, removeStrippedPlaceholderId, replacePendingCompactionMarkerStateIf, reserveProtectedTailDrainTokens, resetLastNudgeCycle, resetLastNudgeCycleIfTailShrank, resetProtectedTailNoEligibleHead, retryPendingSessionCleanups, rollbackProtectedTailDrainReservation, setChannel1NudgeState, setChannel2NudgeState, setLastNudgeUndropped, setPendingCompactionMarkerState, setPendingPiCompactionMarkerState, setPersistedReasoningWatermark, setPersistedTodoPermissionDenied, setPersistedTodoSyntheticAnchor, setSessionWorkMetrics, setStrippedPlaceholderIds, THINKING_BINDING_RECOVERY_ALL_ASSISTANTS, updateSessionMeta, updateWrapupInProgress, WRAPUP_IN_PROGRESS_TTL_MS, type WrapupInProgressState, } from "./storage-meta";
+export { bumpSessionFactsVersion } from "./storage-meta-shared";
+export { addNote, type ConditionCompileStatus, type DismissNoteOutcome, type DismissNoteResult, deleteNote, dismissNote, dismissNotes, getNoteByIdInScope, getNotes, getSessionNotes, type Note, type NoteMutationScope, type NoteStatus, type NoteType, replaceAllSessionNotes, type UpdateNoteOptions, updateNote, } from "./storage-notes";
+export { clearPendingOps, getPendingOps, getPendingOpsCount, queuePendingOp, removePendingOp, } from "./storage-ops";
+export * from "./storage-primers";
+export { bumpProjectMemoryEpoch, bumpProjectUserProfileVersion, deleteProjectState, ensureProjectState, GLOBAL_USER_PROFILE_PROJECT_PATH, getProjectState, type ProjectStateRow, setProjectState, } from "./storage-project-state";
+export { getSourceContents, replaceSourceContent, saveSourceContent, } from "./storage-source";
+export { getSubagentInvocations, getSubagentTotalsBySubagent, recordSubagentInvocation, type SubagentInvocationInput, type SubagentInvocationRow, type SubagentKind, type SubagentTotals, } from "./storage-subagent-invocations";
+export { type ActiveTagTokenAggregate, AGE_RECLAIM_MIN_TOKENS, type AgeReclaimToolTag, adoptFallbackTagMessageId, adoptPiFallbackMessageTag, adoptPiFallbackToolOwnerTag, deleteTagsByMessageId, deriveTagLoadFloor, findAdoptableFallbackTags, findPiFallbackToolOwnerTags, getActiveTagsBySession, getActiveTagTokenAggregate, getActiveTagTokenTotalsByMessage, getActiveToolTagsForAgeReclaim, getAllStatusTagTokenTotalsFlat, getDroppedTagsByNumbers, getMaxDroppedTagNumber, getMaxTagNumberBySession, getMinMessageTagNumberForRawId, getOldestActiveUnprotectedToolTags, getPersistedToolTagAccounting, getTagById, getTagsByNumbers, getTagsBySession, getTagsForPendingOperations, getTopNBySize, getTriggerTagTokenUpperBound, hasPiFallbackMessageTags, hasPiFallbackToolOwnerTags, insertTag, type MessageTokenTotal, markTagsCompactedByMessageIds, type ToolReclaimHintTag, updateCavemanDepth, updateTagDropMode, updateTagMessageId, updateTagStatus, } from "./storage-tags";
+export { clearV22BackfillFailures, deleteV22BackfillFailure, getV22BackfillFailure, listV22BackfillFailures, recordV22BackfillFailure, type V22BackfillErrorClass, type V22BackfillFailureRow, } from "./storage-v22-backfill-failures";
+export { bumpEpochsForWorkspaceMemberSet, bumpEpochsForWorkspaceMembers, computeWorkspaceEpochFingerprint, type ExpandedWorkspaceIdentitySet, expandWorkspaceIdentitySet, expandWorkspaceIdentitySetWithAliases, resolveStoredPathWorkspaceIdentity, resolveWorkspaceIdentitySet, sourceNameForMemory, storedPathBelongsToWorkspace, type WorkspaceIdentitySet, } from "./workspaces";
+//# sourceMappingURL=storage.d.ts.map

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

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

package/dist/features/magic-context/store-generation-rebase.d.ts

@@ -0,0 +1,188 @@
+import { type RawMessage } from "../../hooks/magic-context/read-session-raw";
+import type { Database } from "../../shared/sqlite";
+/**
+ * Which projection of the OpenCode store a session's saved coordinates were
+ * derived against. `v1` is the `message`/`part` reader, `v2` is the
+ * `session_message` reader.
+ */
+export type CoordinateGeneration = "v1" | "v2";
+export interface StoreGenerationRebaseOutcome {
+    /**
+     * `unchanged` — the session's recorded projection already matches the running
+     * host, so nothing was read or written.
+     * `stamped` — the projection was recorded for the first time (or changed) but
+     * no saved coordinate actually moved, so only the stamp was written.
+     * `rebased` — coordinates moved and were re-derived.
+     * `repaired` — the projection already matched, but unresolved compartments
+     * left behind by an older build were placed from their neighbours.
+     */
+    status: "unchanged" | "stamped" | "rebased" | "repaired";
+    generation: CoordinateGeneration;
+    previousGeneration: CoordinateGeneration | null;
+    compartmentsRebased: number;
+    compartmentsUnresolved: number;
+    /** Compartments placed `ok` with at least one end taken from a neighbour. */
+    compartmentsDerived: number;
+    compartmentsResolvedAgain: number;
+    recompCompartmentsRebased: number;
+    recompCompartmentsUnresolved: number;
+    notesRebased: number;
+    notesCleared: number;
+    priorBoundaryRebased: boolean;
+    recompPartialRangeRebased: boolean;
+    compressionDepthRowsDropped: number;
+    chunkEmbeddingsDeleted: number;
+    indexRebuilt: boolean;
+    /** Documents written back into the search index after the rebuild. */
+    indexRowsRebuilt: number;
+    partTagsFolded: number;
+    partTagsRekeyed: number;
+    queuedReductionsDiscarded: number;
+    lkgSlotsDropped: number;
+    frozenPartEntriesDropped: number;
+    healedGaps: number;
+    narrativeGaps: number;
+}
+/**
+ * Durable summary of the last rebase, written so `/mmc-status` and the log can
+ * tell the user what the projection change cost them. Only the facts a user can
+ * act on are kept.
+ */
+export interface CoordinateRebaseNotice {
+    generation: CoordinateGeneration;
+    previousGeneration: CoordinateGeneration | null;
+    at: number;
+    unresolvedCompartments: number;
+    discardedReductions: number;
+    droppedDepthRows: number;
+    healedGaps: number;
+    narrativeGaps: number;
+    /**
+     * Compartments that lost an anchor message but took the missing end from
+     * the neighbouring compartments, with the range they now cover.
+     */
+    derivedCompartments: CompartmentRangeNote[];
+    /** Compartments that could not be placed even from their neighbours. */
+    unresolvedCompartmentRanges: CompartmentRangeNote[];
+    /**
+     * When neighbour recovery last ran over this session's compartments (ms),
+     * or null if it never has. Its presence is what keeps the one-time repair
+     * of sessions stamped by an older build from running again.
+     */
+    neighbourRecoveryAt: number | null;
+}
+/** One compartment named in the rebase notice: its sequence and message range. */
+export interface CompartmentRangeNote {
+    sequence: number;
+    start: number;
+    end: number;
+}
+export declare function readCoordinateGeneration(db: Database, sessionId: string): CoordinateGeneration | null;
+export declare function readCoordinateRebaseNotice(db: Database, sessionId: string): CoordinateRebaseNotice | null;
+/**
+ * One user-visible line describing what the last projection change cost, or null
+ * when the rebase took nothing away.
+ */
+export declare function formatCoordinateRebaseNotice(notice: CoordinateRebaseNotice): string | null;
+export interface RebaseSessionCoordinatesArgs {
+    db: Database;
+    sessionId: string;
+    /** Projection the running host serves for this session. */
+    generation: CoordinateGeneration;
+    /**
+     * Reads that projection. Called at most once, and only when a change is
+     * possible; not called at all when `readMessagePages` is supplied.
+     */
+    readMessages: (sessionId: string) => RawMessage[];
+    /**
+     * The same messages as `readMessages`, in ascending ordinal pages, so the
+     * whole history never has to be held at once. Preferred when present, and
+     * iterated at most once per call.
+     */
+    readMessagePages?: (sessionId: string) => Iterable<RawMessage[]>;
+}
+/**
+ * Re-derive every position-keyed coordinate this session saved, from the message
+ * ids that survived, against the projection the running host serves.
+ *
+ * Message ids are stable across the OpenCode 1.x/2.x store conversion but the
+ * positions are not: converting a 1.x store splits some turns into two rows and
+ * folds others into one, and the v1 tables are kept, so a user can be served
+ * either projection on any given launch. Everything Magic Context saved as "the
+ * Nth message" therefore has to be re-derived from the anchor ids whenever the
+ * projection this session was last read under is not the one now in front of us.
+ *
+ * Nothing is guessed. An anchor the running projection does not contain marks
+ * its row unresolved instead of being snapped to a neighbouring position, and
+ * state with no id anchor at all (the search index, chunk windows, compression
+ * depth) is rebuilt from the authoritative source rather than renumbered.
+ *
+ * The row rewrites, the index clear and the generation stamp commit together, so
+ * a crash leaves the session either fully rebased or untouched; an untouched
+ * session still has the old stamp, so the next pass runs this again.
+ *
+ * This form runs to completion without giving up the thread. The request path
+ * uses `rebaseSessionCoordinatesAsync`, which does the same work but lets other
+ * work run between history pages and between index-rebuild chunks.
+ */
+export declare function rebaseSessionCoordinates(args: RebaseSessionCoordinatesArgs): StoreGenerationRebaseOutcome;
+/**
+ * `rebaseSessionCoordinates` for the request path: identical work and
+ * identical rows, but the thread is released every ~20 ms at the points where
+ * that is safe, so a long first reconciliation no longer freezes the host.
+ *
+ * It is released only outside write transactions: while the history is read
+ * (nothing written yet, and every saved row is read again after the read
+ * ends, so work done meanwhile is seen), and between the search-index rebuild
+ * chunks that follow the commit (each chunk is its own transaction and the
+ * index is designed to be caught up in pieces). The coordinate rewrite, the
+ * index clear and the generation stamp still commit as one transaction that
+ * nothing else runs inside, and the caller's promise settles only after the
+ * stamp has committed, so a prompt built after awaiting this never sees the old
+ * coordinates.
+ *
+ * Two calls for the same session on one connection do not run side by side:
+ * the second waits for the first and then finds the session already stamped.
+ */
+export declare function rebaseSessionCoordinatesAsync(args: RebaseSessionCoordinatesArgs): Promise<StoreGenerationRebaseOutcome>;
+export interface NeighbourRecoveryResult {
+    /** Compartment rows whose coordinates or status were rewritten. */
+    rowsRewritten: number;
+    /** Rows placed `ok` from a neighbour, with their new ranges. */
+    derived: CompartmentRangeNote[];
+    /** Rows that are still unresolved after recovery, with their clamped ranges. */
+    unresolved: CompartmentRangeNote[];
+}
+export interface RecoverUnresolvedCompartmentsArgs {
+    db: Database;
+    sessionId: string;
+    /**
+     * The ordinal the running host serves a message id at, or undefined when it
+     * serves no such message. Only called for the anchors of unresolved rows.
+     */
+    resolveOrdinal: (messageId: string) => number | undefined;
+    /** Names the caller in the log line. */
+    reason: string;
+}
+/**
+ * Place the session's unresolved compartments from their neighbours, without a
+ * projection change.
+ *
+ * Rows marked `ok` are trusted exactly as stored: their ordinals already
+ * describe the projection this session is stamped with, and re-deriving them
+ * from anchors here would turn every compartment whose raw rows the host has
+ * since pruned into an unresolved one. Only unresolved rows are re-examined,
+ * with the same rules the rebase uses (see `recoverFromNeighbours`), so a row
+ * whose missing anchor its neighbours determine becomes `ok` and one they do
+ * not is clamped off its `ok` neighbours.
+ *
+ * The cached m0/m1 render is deliberately left in place. Rewriting a
+ * compartment row changes what the next render produces, and that change must
+ * reach the provider on a pass that is already rebuilding the prefix (the
+ * historian's next publish is one), never on a pass that replays the cached
+ * bytes.
+ */
+export declare function recoverUnresolvedCompartments(args: RecoverUnresolvedCompartmentsArgs): NeighbourRecoveryResult;
+/** Single-line summary of one session's rebase, in the order an operator reads it. */
+export declare function formatRebaseLogLine(outcome: StoreGenerationRebaseOutcome, elapsedMs: number): string;
+//# sourceMappingURL=store-generation-rebase.d.ts.map

package/dist/features/magic-context/store-generation-rebase.d.ts.map

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

package/dist/features/magic-context/subagent-token-capture.d.ts

@@ -0,0 +1,35 @@
+import type { HarnessId } from "../../shared/harness";
+import type { Database } from "../../shared/sqlite";
+import { type SubagentInvocationStatus, type SubagentKind } from "./storage-subagent-invocations";
+export interface TokenTotals {
+    input: number;
+    output: number;
+    cacheRead: number;
+    cacheWrite: number;
+}
+export interface LastAssistantModel {
+    providerId: string | null;
+    modelId: string | null;
+}
+export interface ChildInvocationRecordInput {
+    db: Database | null;
+    parentSessionId: string;
+    harness: HarnessId;
+    subagent: SubagentKind;
+    startedAt: number;
+    endedAt?: number;
+    status: SubagentInvocationStatus;
+    task?: string | null;
+    messages?: unknown[];
+    tokens?: TokenTotals;
+    providerId?: string | null;
+    modelId?: string | null;
+    error?: unknown;
+    parentInvocationId?: number | null;
+}
+export declare function failedInvocationStatus(error: unknown): SubagentInvocationStatus;
+export declare function emptyTokenTotals(): TokenTotals;
+export declare function sumTokensFromChildMessages(messages: unknown[]): TokenTotals;
+export declare function findLastAssistantModel(messages: unknown[]): LastAssistantModel;
+export declare function recordChildInvocation(input: ChildInvocationRecordInput): number | null;
+//# sourceMappingURL=subagent-token-capture.d.ts.map

package/dist/features/magic-context/subagent-token-capture.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"subagent-token-capture.d.ts","sourceRoot":"","sources":["../../../src/features/magic-context/subagent-token-capture.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,sBAAsB,CAAC;AAEtD,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,qBAAqB,CAAC;AACpD,OAAO,EAEH,KAAK,wBAAwB,EAC7B,KAAK,YAAY,EACpB,MAAM,gCAAgC,CAAC;AAExC,MAAM,WAAW,WAAW;IACxB,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;IACf,SAAS,EAAE,MAAM,CAAC;IAClB,UAAU,EAAE,MAAM,CAAC;CACtB;AAED,MAAM,WAAW,kBAAkB;IAC/B,UAAU,EAAE,MAAM,GAAG,IAAI,CAAC;IAC1B,OAAO,EAAE,MAAM,GAAG,IAAI,CAAC;CAC1B;AAED,MAAM,WAAW,0BAA0B;IACvC,EAAE,EAAE,QAAQ,GAAG,IAAI,CAAC;IACpB,eAAe,EAAE,MAAM,CAAC;IACxB,OAAO,EAAE,SAAS,CAAC;IACnB,QAAQ,EAAE,YAAY,CAAC;IACvB,SAAS,EAAE,MAAM,CAAC;IAClB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,MAAM,EAAE,wBAAwB,CAAC;IACjC,IAAI,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IACrB,QAAQ,CAAC,EAAE,OAAO,EAAE,CAAC;IACrB,MAAM,CAAC,EAAE,WAAW,CAAC;IACrB,UAAU,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAC3B,OAAO,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IACxB,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,kBAAkB,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;CACtC;AAmDD,wBAAgB,sBAAsB,CAAC,KAAK,EAAE,OAAO,GAAG,wBAAwB,CAkB/E;AAED,wBAAgB,gBAAgB,IAAI,WAAW,CAE9C;AAED,wBAAgB,0BAA0B,CAAC,QAAQ,EAAE,OAAO,EAAE,GAAG,WAAW,CAgB3E;AAED,wBAAgB,sBAAsB,CAAC,QAAQ,EAAE,OAAO,EAAE,GAAG,kBAAkB,CAM9E;AAED,wBAAgB,qBAAqB,CAAC,KAAK,EAAE,0BAA0B,GAAG,MAAM,GAAG,IAAI,CAoCtF"}

package/dist/features/magic-context/tag-input.d.ts

@@ -0,0 +1,4 @@
+export declare const TAG_INPUT_ERROR = "Error: tag must be one positive integer: 12, \"12\", \"\u00A712\u00A7\", \"\u00A712\", \"tag 12\", or \"[dropped \u00A712\u00A7]\" (surrounding whitespace is allowed).";
+/** Normalize copied transcript handles without accepting embedded or multiple numbers. */
+export declare function parseTagInput(value: unknown): number;
+//# sourceMappingURL=tag-input.d.ts.map

package/dist/features/magic-context/tag-input.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tag-input.d.ts","sourceRoot":"","sources":["../../../src/features/magic-context/tag-input.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,eAAe,4KAC8G,CAAC;AAE3I,0FAA0F;AAC1F,wBAAgB,aAAa,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,CAWpD"}

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

@@ -0,0 +1,119 @@
+import type { Database } from "../../shared/sqlite";
+import { type TagTokenCounts } from "./storage-tags";
+import type { TagEntry } from "./types";
+export declare function makeToolCompositeKey(ownerMsgId: string, callId: string): string;
+/**
+ * Narrowed type for non-tool tag operations. The compile-time exclusion
+ * of `"tool"` here is the v3.3.1 Layer C contract: every tool path MUST
+ * use `assignToolTag`/`getToolTag` so composite identity propagates.
+ *
+ * Any caller passing `"tool"` to `assignTag` or `getTag` triggers a TS
+ * compile error at the call site. Defense-in-depth: the runtime body
+ * also throws if it ever sees a "tool" type at runtime (caught by
+ * `as any` casts in legacy code).
+ */
+type NonToolTagType = Exclude<TagEntry["type"], "tool">;
+export interface ToolTagAccounting {
+    byteSize: number;
+    tokenCount: number | null;
+    inputByteSize: number;
+    inputTokenCount: number | null;
+}
+export interface TaggerHeapStats {
+    sessionCount: number;
+    assignmentEntries: number;
+    toolAccountingEntries: number;
+    loadSignatureEntries: number;
+    sessions: Array<{
+        sessionId: string;
+        assignments: number;
+        toolAccounting: number;
+    }>;
+}
+export interface Tagger {
+    /**
+     * Assign a tag for a non-tool entity (message text or file part).
+     *
+     * Tool tags MUST use {@link assignToolTag}; the `type` parameter
+     * here is narrowed at compile time to forbid `"tool"`.
+     */
+    assignTag(sessionId: string, messageId: string, type: NonToolTagType, byteSize: number, db: Database, reasoningByteSize?: number, toolName?: string | null, inputByteSize?: number, 
+    /**
+     * Pi-only: fingerprint of the raw message this tag is created for,
+     * persisted on the tag row so a later pass can adopt a fallback-id tag
+     * onto the real SessionEntry id. OpenCode passes undefined → column
+     * stays NULL → no behavior change.
+     */
+    entryFingerprint?: string | null, 
+    /**
+     * Lazy per-tag token computation, invoked by the tagger ONLY on the
+     * fresh-insert branch (never when an existing tag is rebound). This is
+     * what keeps tokenization "compute once, ever" — steady-state passes
+     * pay nothing. Returns the real-tokenizer counts for this tag's content.
+     */
+    tokenThunk?: () => TagTokenCounts): number;
+    /**
+     * Look up the tag number for a non-tool entity.
+     *
+     * The `type` parameter is required (and narrowed to non-tool) so a
+     * future tool-tag lookup can't accidentally fall through here. Use
+     * {@link getToolTag} for tool lookups.
+     */
+    getTag(sessionId: string, messageId: string, type: NonToolTagType): number | undefined;
+    /**
+     * Assign a tag for a tool invocation. Composite identity
+     * `(sessionId, callId, ownerMsgId)` is mandatory — pre-v3.3.1 the
+     * tagger keyed tool tags by bare callId, and two assistant turns
+     * reusing the same callId would silently bind to the same tag,
+     * inheriting the older tag's drop status.
+     *
+     * `ownerMsgId` is the assistant message id that hosts the tool
+     * invocation. For Pi parallel-tool-calls without `part.id`, callers
+     * pass a synthetic locator equal to the contentId (owner == callId)
+     * to satisfy the contract while preserving the legacy "each part
+     * gets its own tag" behavior.
+     */
+    assignToolTag(sessionId: string, callId: string, ownerMsgId: string, byteSize: number, db: Database, reasoningByteSize?: number, toolName?: string | null, inputByteSize?: number, 
+    /** Lazy token computation — invoked only on fresh insert (see assignTag). */
+    tokenThunk?: () => TagTokenCounts): number;
+    /**
+     * Look up the tag number for a tool invocation by composite
+     * identity.
+     */
+    getToolTag(sessionId: string, callId: string, ownerMsgId: string): number | undefined;
+    /** Persisted accounting loaded in the same scan as tool-tag identities. */
+    getToolTagAccounting(sessionId: string, callId: string, ownerMsgId: string): ToolTagAccounting | undefined;
+    /** Keep the loaded accounting mirror synchronized with same-connection writes. */
+    setToolTagAccounting(sessionId: string, tagNumber: number, accounting: ToolTagAccounting): void;
+    bindTag(sessionId: string, messageId: string, tagNumber: number): void;
+    /**
+     * Remove a stale in-memory assignment key. Used by Pi fallback-tag
+     * adoption after a tag's message_id is migrated from the pi-msg-*
+     * fallback to the real id: the old fallback key must be dropped so it
+     * doesn't linger as an alias to the same tag number.
+     */
+    unbindTag(sessionId: string, messageId: string): void;
+    /**
+     * Bind a tool tag by composite key. The in-memory map keys this as
+     * `${ownerMsgId}\x00${callId}`.
+     */
+    bindToolTag(sessionId: string, callId: string, ownerMsgId: string, tagNumber: number): void;
+    /**
+     * Remove a stale tool composite assignment. Used by Pi fallback-owner
+     * adoption when a tool tag moves from a synthetic pi-msg-* owner to the
+     * real SessionEntry id (or when a duplicate real-owner row is folded away).
+     */
+    unbindToolTag(sessionId: string, ownerMsgId: string, callId: string): void;
+    getAssignments(sessionId: string): ReadonlyMap<string, number>;
+    resetCounter(sessionId: string, db: Database): void;
+    getCounter(sessionId: string): number;
+    initFromDb(sessionId: string, db: Database, floor?: number): void;
+    /** Returns the database tag version recorded when this session's map was last loaded. */
+    getLoadedTagsVersion?(sessionId: string, db: Database): number | undefined;
+    cleanup(sessionId: string): void;
+    /** Present on the production tagger; optional keeps lightweight test doubles source-compatible. */
+    getHeapStats?(): TaggerHeapStats;
+}
+export declare function createTagger(): Tagger;
+export {};
+//# sourceMappingURL=tagger.d.ts.map

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

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

package/dist/features/magic-context/tool-definition-tokens.d.ts

@@ -0,0 +1,90 @@
+/**
+ * Tool-definition token measurement store.
+ *
+ * OpenCode's `tool.definition` hook fires once per tool per
+ * `ToolRegistry.tools()` call, with `{ toolID }` as input and
+ * `{ description, parameters }` as output. Crucially the hook input does NOT
+ * carry `sessionID` — the tool set is computed per
+ * `{providerID, modelID, agent}` combination, independent of session.
+ *
+ * We measure each tool's description + JSON-schema parameters, tokenize with
+ * the same Claude tokenizer used everywhere else in the plugin, and store
+ * per-tool totals keyed by `${providerID}/${modelID}/${agentName}`. Inner map
+ * keys on `toolID` so every hook fire idempotently overwrites its own slot
+ * (same tool set on each turn → same key → same measured total).
+ *
+ * Consumers (RPC sidebar/status handlers) look up the active session's
+ * measurement via `getMeasuredToolDefinitionTokens(providerID, modelID,
+ * agentName)`. Returns `undefined` when the key has never been measured — the
+ * caller is expected to fall back to residual math or show zero.
+ *
+ * Persistence (v9+): measurements are also written to SQLite so that a
+ * plugin restart can repopulate the in-memory map without waiting for the
+ * next chat.message → tool.definition hook chain. The in-memory Map remains
+ * the hot read path; SQLite is a write-through mirror that backs cold starts.
+ * If `setDatabase()` hasn't been called yet (cold path before openDatabase
+ * completes), `recordToolDefinition` still updates the in-memory map and
+ * silently skips persistence — first measurement after init lands both.
+ *
+ * Hot-path optimization: `tool.definition` fires once per tool per LLM
+ * flight (~58 tools × 5–18ms SQLite write = ~1.4s of redundant work per
+ * flight on large MC databases). Tool descriptions and parameters almost
+ * never change between flights, so we keep a per-key content-fingerprint
+ * Map and bail out at the top of `recordToolDefinition` when the new fire
+ * carries the same fingerprint as the previous one. This collapses
+ * steady-state hook overhead from ~1.4s to <1ms while still re-measuring
+ * any tool whose description/schema actually changed (e.g. MCP server
+ * restart, OpenCode upgrade). Cached prepared statement avoids repeated
+ * `db.prepare()` compile cost on first-flight rebuilds.
+ */
+import type { Database } from "../../shared/sqlite";
+/**
+ * Hash the observed names in the provider tool set for one model/agent route.
+ *
+ * Tool names alone identify the prefix change this marker explains. Schema
+ * fingerprints remain necessary for measurement de-duplication, but including
+ * them here would add cost without improving cache-bust attribution. An empty
+ * string means the route has not reported any tool definitions, not an empty
+ * provider `tools` array.
+ */
+export declare function getCurrentToolSetHash(providerID: string, modelID: string, agentName: string | undefined): string;
+/**
+ * Register the database used to persist measurements. Called by
+ * openDatabase() after runMigrations() has ensured the
+ * `tool_definition_measurements` table exists. Subsequent
+ * recordToolDefinition() calls will write through to SQLite.
+ */
+export declare function setDatabase(db: Database): void;
+/**
+ * Populate the in-memory measurements map from the
+ * `tool_definition_measurements` table. Called once at startup after
+ * setDatabase(), before the first sidebar snapshot or status query, so the
+ * sidebar's "Tool Defs" segment shows the correct value immediately on
+ * restart instead of 0.
+ *
+ * Idempotent: re-running over the same DB reapplies the same values; the
+ * inner-map key (toolID) ensures duplicates overwrite rather than accumulate.
+ */
+export declare function loadToolDefinitionMeasurements(db: Database): void;
+/**
+ * Tokenize a single tool's schema and store it under the given key. Called
+ * from the `tool.definition` plugin hook once per tool per flight. Same
+ * toolID on a later flight overwrites its slot — the total for the key stays
+ * consistent even if descriptions or parameters drift between turns.
+ */
+export declare function recordToolDefinition(providerID: string, modelID: string, agentName: string | undefined, toolID: string, description: string, parameters: unknown): void;
+/**
+ * Returns the summed measured tokens for a `{provider, model, agent}` key,
+ * or `undefined` when never measured (e.g. fresh session before first turn).
+ */
+export declare function getLargestMeasuredToolDefinitionTokens(): number | undefined;
+export declare function getMeasuredToolDefinitionTokens(providerID: string, modelID: string, agentName: string | undefined): number | undefined;
+/** Test helper: reset the store so suites don't leak measurements. */
+export declare function __resetToolDefinitionMeasurements(): void;
+/** Inspection helper: snapshot the current store (for debug logging/tests). */
+export declare function getToolDefinitionSnapshot(): Array<{
+    key: string;
+    totalTokens: number;
+    toolCount: number;
+}>;
+//# sourceMappingURL=tool-definition-tokens.d.ts.map

package/dist/features/magic-context/tool-definition-tokens.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tool-definition-tokens.d.ts","sourceRoot":"","sources":["../../../src/features/magic-context/tool-definition-tokens.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsCG;AAIH,OAAO,KAAK,EAAE,QAAQ,EAAa,MAAM,qBAAqB,CAAC;AA0C/D;;;;;;;;GAQG;AACH,wBAAgB,qBAAqB,CACjC,UAAU,EAAE,MAAM,EAClB,OAAO,EAAE,MAAM,EACf,SAAS,EAAE,MAAM,GAAG,SAAS,GAC9B,MAAM,CAKR;AAED;;;;;GAKG;AACH,wBAAgB,WAAW,CAAC,EAAE,EAAE,QAAQ,GAAG,IAAI,CAK9C;AAED;;;;;;;;;GASG;AACH,wBAAgB,8BAA8B,CAAC,EAAE,EAAE,QAAQ,GAAG,IAAI,CAkCjE;AAED;;;;;GAKG;AACH,wBAAgB,oBAAoB,CAChC,UAAU,EAAE,MAAM,EAClB,OAAO,EAAE,MAAM,EACf,SAAS,EAAE,MAAM,GAAG,SAAS,EAC7B,MAAM,EAAE,MAAM,EACd,WAAW,EAAE,MAAM,EACnB,UAAU,EAAE,OAAO,GACpB,IAAI,CAwEN;AAED;;;GAGG;AACH,wBAAgB,sCAAsC,IAAI,MAAM,GAAG,SAAS,CAQ3E;AAED,wBAAgB,+BAA+B,CAC3C,UAAU,EAAE,MAAM,EAClB,OAAO,EAAE,MAAM,EACf,SAAS,EAAE,MAAM,GAAG,SAAS,GAC9B,MAAM,GAAG,SAAS,CAOpB;AAED,sEAAsE;AACtE,wBAAgB,iCAAiC,IAAI,IAAI,CAKxD;AAED,+EAA+E;AAC/E,wBAAgB,yBAAyB,IAAI,KAAK,CAAC;IAC/C,GAAG,EAAE,MAAM,CAAC;IACZ,WAAW,EAAE,MAAM,CAAC;IACpB,SAAS,EAAE,MAAM,CAAC;CACrB,CAAC,CAMD"}

package/dist/features/magic-context/tool-owner-backfill.d.ts

@@ -0,0 +1,93 @@
+/**
+ * Tool-owner backfill (plan v3.3.1, Layer B).
+ *
+ * Migration v10 added `tool_owner_message_id` to the tags table. The
+ * runtime carries every new tool tag with a non-NULL owner, but the
+ * 185k+ existing rows in user DBs need their owner column populated to
+ * make the v10 fix fully effective. The backfill pass iterates each
+ * session that has tool tags with NULL owner, queries the OpenCode DB
+ * for the temporally-earliest assistant message that invoked each
+ * callID, and writes the owner via a NULL-guarded UPDATE so the
+ * runtime can lazily adopt rows the backfill couldn't see (e.g. Pi
+ * sessions, deleted OC sessions, transient OC-DB-unavailable cases).
+ *
+ * Concurrency model:
+ *   - Per-session advisory lease via `tool_owner_backfill_state`.
+ *   - 5-minute lease, renewed every 60s during chunked execution.
+ *   - Sibling instances skip sessions whose lease is held and active.
+ *   - Process-death cleanup falls out for free: better-sqlite3 + WAL
+ *     drops all locks at process exit, and the `lease_expires_at`
+ *     column is the only durable state. A crashed process's session
+ *     becomes claimable as soon as the lease wall-clock expires.
+ *   - NULL-guarded UPDATE: backfill never clobbers a row already
+ *     adopted at runtime.
+ *
+ * Skip vs fail semantics:
+ *   - When OpenCode DB is missing (e.g. Pi-only install), every
+ *     session gets marked 'skipped' in the state table. Lazy adoption
+ *     handles the orphans at runtime.
+ *   - When OpenCode DB exists but a specific session is missing or
+ *     yields zero matches, that session is marked 'skipped' too.
+ *     Same lazy-adoption fallback covers it.
+ *   - A session error during backfill (SQLITE_BUSY, malformed JSON,
+ *     anything) is logged and the session is left in 'pending'/
+ *     'running' for a retry on next plugin start. Backfill never
+ *     fail-closes the plugin — it's defense-in-depth on top of
+ *     Layer C lazy adoption.
+ *
+ * Idempotency:
+ *   - The NULL guard makes UPDATE idempotent: re-running against an
+ *     already-backfilled row matches zero rows and moves on.
+ *   - The state table makes session bookkeeping idempotent: a
+ *     completed session is never re-processed; a session with unresolved
+ *     NULL-owner rows stays pending for later lazy adoption/retry.
+ */
+import type { Database } from "../../shared/sqlite";
+interface BackfillStateRow {
+    session_id: string;
+    status: string;
+    started_at: number | null;
+    lease_expires_at: number | null;
+    completed_at: number | null;
+    last_error: string | null;
+}
+interface BackfillResult {
+    sessionsProcessed: number;
+    sessionsSkippedNoOcDb: number;
+    sessionsSkippedNoMatches: number;
+    sessionsCompleted: number;
+    sessionsBlockedByLease: number;
+    sessionsErrored: number;
+    rowsUpdated: number;
+    rowsLeftNull: number;
+    durationMs: number;
+}
+/**
+ * Top-level entry point. Called from `openDatabase()` after
+ * `runMigrations()` returns. Synchronous; runs to completion before
+ * returning so the first transform pass on a fresh upgrade sees a
+ * mostly-backfilled DB.
+ *
+ * Worst-case runtime on the user's playground DB (3,276 sessions,
+ * 185,716 tool tags): ~25 seconds. Well under the 60-second budget.
+ */
+export declare function runToolOwnerBackfill(db: Database): BackfillResult;
+/**
+ * Returns true when at least one tool tag exists with NULL owner that
+ * isn't already marked completed/skipped in the state table.
+ *
+ * Treating "no NULL-owner tags" as "no work" lets us short-circuit on
+ * fresh DBs (every row is born with a non-NULL owner) and on already-
+ * backfilled DBs (re-running is a no-op).
+ */
+export declare function isToolOwnerBackfillNeeded(db: Database): boolean;
+/** Test-only hook for the clear-versus-terminal-transition race. */
+export declare function _markSessionSkippedForTests(db: Database, sessionId: string): void;
+/**
+ * Test-only: read the backfill state for a session. Exposed via the
+ * normal export but namespaced by underscore so it doesn't show up in
+ * the public surface area outside tests.
+ */
+export declare function _getBackfillState(db: Database, sessionId: string): BackfillStateRow | null;
+export {};
+//# sourceMappingURL=tool-owner-backfill.d.ts.map