@cortexkit/opencode-magic-context 0.49.6 → 0.49.7

package/src/shared/sqlite.ts

@@ -72,14 +72,21 @@ export function registerSlowWriteReporter(reporter: SlowWriteReporter): void {
  */
 type SqliteDiagnosticSink = (message: string) => void;
 let sqliteDiagnosticSink: SqliteDiagnosticSink | undefined;
+let sqliteDiagnosticHost: () => string = () => "unknown";
 
-export function registerSqliteDiagnosticSink(sink: SqliteDiagnosticSink): void {
+export function registerSqliteDiagnosticSink(
+    sink: SqliteDiagnosticSink,
+    host?: () => string,
+): void {
     sqliteDiagnosticSink = sink;
+    if (host) sqliteDiagnosticHost = host;
 }
 
 function reportSqliteDiagnostic(message: string): void {
     try {
-        sqliteDiagnosticSink?.(`[magic-context] ${message}`);
+        sqliteDiagnosticSink?.(
+            `[magic-context] ${message} pid=${process.pid} host=${sqliteDiagnosticHost()}`,
+        );
     } catch {
         // Diagnostics must never change the outcome of the write they describe.
     }
@@ -393,9 +400,18 @@ function installTransactionRouting(db: BetterSqlite3.Database, readonly: boolean
                 // A transaction that ended without passing through exec (for
                 // example an automatic rollback) must not be timed as this one.
                 openWriterTransactions.delete(db);
-                if (transformPassScope.getStore()?.active || backgroundWriterScope.getStore())
+                if (transformPassScope.getStore()?.active || backgroundWriterScope.getStore()) {
                     acquireShort(db, () => nativeExec(sql), sql.trim());
-                else nativeExec(sql);
+                } else {
+                    nativeExec(sql);
+                    openWriterTransactions.set(db, {
+                        site: sql.trim(),
+                        lane: "background",
+                        acquireMs: 0,
+                        attempts: 1,
+                        acquiredAt: performance.now(),
+                    });
+                }
                 return db;
             }
             if (WRITER_TRANSACTION_END.test(sql) && openWriterTransactions.has(db))
@@ -943,7 +959,7 @@ const SHORT_BUSY_TIMEOUT_MS = 25;
 const FOREGROUND_IN_PASS_BUSY_TIMEOUT_MS = 2_000;
 const FOREGROUND_ACQUISITION_BUDGET_MS = 16_500;
 /** Waiting this long for the writer lock, or holding it this long, is logged. */
-const SLOW_WRITER_LOG_MS = 250;
+const SLOW_WRITER_LOG_MS = 100;
 const WRITER_TRANSACTION_END = /^\s*(?:COMMIT|END|ROLLBACK)(?:\s+TRANSACTION)?\s*;?\s*$/i;
 
 type WriterLane = "foreground" | "background";
@@ -991,25 +1007,33 @@ function foregroundWaitLease() {
 function withAutocommitTimeout<T>(db: Database, operation: () => T): T {
     assertTransformWrite();
     const lease = foregroundWaitLease();
-    if (isInTransaction(db) || (!lease && !backgroundWriterScope.getStore())) return operation();
-    const previous = pragmaNumber(db, "busy_timeout");
-    db.exec(
-        `PRAGMA busy_timeout=${lease ? Math.floor(Math.min(lease.remainingWaitMs, lease.guard?.remainingMs() ?? Infinity)) : SHORT_BUSY_TIMEOUT_MS}`,
-    );
+    if (isInTransaction(db)) return operation();
+    const scoped = lease || backgroundWriterScope.getStore();
+    const previous = scoped ? pragmaNumber(db, "busy_timeout") : null;
+    if (scoped)
+        db.exec(
+            `PRAGMA busy_timeout=${lease ? Math.floor(Math.min(lease.remainingWaitMs, lease.guard?.remainingMs() ?? Infinity)) : SHORT_BUSY_TIMEOUT_MS}`,
+        );
     const started = performance.now();
+    let completed = false;
     try {
-        return operation();
+        const result = operation();
+        completed = true;
+        return result;
     } catch (error) {
         if (lease && isTransientSqliteError(error))
             throw new SqliteAcquisitionBusyError(error, "autocommit");
         throw error;
     } finally {
-        if (lease)
-            lease.remainingWaitMs = Math.max(
-                0,
-                lease.remainingWaitMs - (performance.now() - started),
-            );
+        const elapsed = performance.now() - started;
+        if (lease) lease.remainingWaitMs = Math.max(0, lease.remainingWaitMs - elapsed);
         if (previous !== null) db.exec(`PRAGMA busy_timeout=${previous}`);
+        // Native autocommit does not expose the instant its lock was acquired.
+        // Label the upper bound so a waiting statement is not blamed as a holder.
+        if (elapsed >= SLOW_WRITER_LOG_MS)
+            reportSqliteDiagnostic(
+                `sqlite writer site=autocommit lane=${lease ? "foreground" : "background"} elapsed_ms=${Math.round(elapsed)} timing=statement_including_acquisition outcome=${completed ? "completed" : "failed"} caller=${writerCaller()}`,
+            );
     }
 }
 
@@ -1071,20 +1095,18 @@ function acquireShort(db: Database, acquire: () => unknown, site: string): void
  * `acquireShort`, then report how long the writer waited for the lock
  * (`acquire_ms`) and how long it then held it (`hold_ms`) when either crosses
  * the threshold. A long hold blocks every other process's writer, so it is
- * worth seeing even when the lock itself came quickly. The native end statement's
- * `end_ms` is reported separately, so a slow FTS merge or checkpoint at COMMIT
- * is not mistaken for acquisition time.
+ * worth seeing even when the lock itself came quickly. This interval includes
+ * COMMIT: an automatic PASSIVE checkpoint can run after writer-lock release,
+ * so hold_ms is a conservative upper bound, not proof of continuous ownership.
  */
 function endWriterTransaction(db: Database, end: () => unknown, sql: string): unknown {
     let ended = false;
-    const endStarted = performance.now();
     try {
         const result = end();
         ended = true;
         return result;
     } finally {
         const open = openWriterTransactions.get(db);
-        const endMs = performance.now() - endStarted;
         // A COMMIT that failed with the transaction still open has not ended it.
         if (open && !isInTransaction(db)) {
             openWriterTransactions.delete(db);
@@ -1096,13 +1118,32 @@ function endWriterTransaction(db: Database, end: () => unknown, sql: string): un
                       ? "committed"
                       : "failed";
                 reportSqliteDiagnostic(
-                    `sqlite writer site=${open.site} lane=${open.lane} acquire_ms=${Math.round(open.acquireMs)} hold_ms=${Math.round(holdMs)} end_ms=${Math.round(endMs)} attempts=${open.attempts} outcome=${outcome}`,
+                    `sqlite writer site=${open.site} lane=${open.lane} acquire_ms=${Math.round(open.acquireMs)} hold_ms=${Math.round(holdMs)} attempts=${open.attempts} outcome=${outcome} timing=through_commit_upper_bound caller=${writerCaller()}`,
                 );
             }
         }
     }
 }
 
+// Capture a stack only for slow writes. Synchronous COMMIT retains the writer's
+// caller, so fast transactions need neither stack allocation nor source mapping.
+function writerCaller(): string {
+    return (
+        new Error().stack
+            ?.split("\n")
+            .find(
+                (line) =>
+                    line.includes(" at ") &&
+                    !/[/\\]sqlite\.[tj]s[:)]/.test(line) &&
+                    !/\b(?:writerCaller|endWriterTransaction|withAutocommitTimeout|value)\b/.test(
+                        line,
+                    ),
+            )
+            ?.trim()
+            .replace(/\s+/g, "_") ?? "unknown"
+    );
+}
+
 /** Begin an immediate transaction with bounded asynchronous retries on writer contention.
  * Callers must recheck any lease or source snapshot after this function returns.
  * Resolves with the `performance.now()` time at which BEGIN IMMEDIATE succeeded,

package/src/shared/tag-transcript.ts

@@ -55,6 +55,7 @@ import {
     updateTagTokenCount,
 } from "../features/magic-context/storage-tags";
 import { makeToolCompositeKey, type Tagger } from "../features/magic-context/tagger";
+import type { TagEntry } from "../features/magic-context/types";
 import { droppedInputMarker } from "../hooks/magic-context/dropped-input-guard";
 import { applyEditMarkerToInput } from "../hooks/magic-context/edit-marker";
 import { estimateImageTokensFromDataUrl } from "../hooks/magic-context/image-token-estimate";
@@ -121,6 +122,122 @@ export interface TagTranscriptResult {
     targets: Map<number, TagTarget>;
 }
 
+/**
+ * Bind durable drops to a saved request without tagging it again. Recovery must
+ * not allocate identities, inject prefixes, or write accounting while the store
+ * is failing. Reuse the normal targets so persisted modes render identically.
+ */
+export function buildPersistedDropTargets(
+    transcript: Transcript,
+    tags: readonly TagEntry[],
+    options: { allowReasoningPrefixRewrite?: boolean } = {},
+): Map<number, TagTarget> {
+    const targets = new Map<number, TagTarget>();
+    const tools = new Map(
+        tags
+            .filter((tag) => tag.type === "tool")
+            .map((tag) => [makeToolCompositeKey(tag.toolOwnerMessageId ?? "", tag.messageId), tag]),
+    );
+    const textTags = new Map(
+        tags.filter((tag) => tag.type !== "tool").map((tag) => [tag.messageId, tag]),
+    );
+    const byNumber = new Map(tags.map((tag) => [tag.tagNumber, tag]));
+    const aggregates = new Map<
+        string,
+        { tag?: TagEntry; occurrences: ToolOccurrence[]; reasoning: boolean }
+    >();
+    const pending = new Map<string, string[]>();
+    const resolved = new Map<string, string>();
+    const ambiguousCalls = new Set<string>();
+    const end = new ConversationEndGuard(transcript.messages);
+    for (const message of transcript.messages) {
+        let ordinal = 0;
+        let resultRun: { callId: string; key: string } | undefined;
+        const parts = message.parts;
+        const reasoning =
+            message.requiresToolArcSkeleton ??
+            (message.info.role === "assistant" && parts.some((part) => part.kind === "thinking"));
+        for (const part of parts) {
+            if (part.kind !== "tool_result") resultRun = undefined;
+            if (part.kind === "text") {
+                const prefix = /^§(\d+)§\s/.exec(part.getText() ?? "");
+                const tag =
+                    (prefix ? byNumber.get(Number(prefix[1])) : undefined) ??
+                    textTags.get(`${message.info.id}:p${ordinal}`);
+                ordinal++;
+                if (tag && tag.type !== "tool")
+                    targets.set(tag.tagNumber, buildTextTarget(part, message, ""));
+            } else if ((part.kind === "tool_use" || part.kind === "tool_result") && part.id) {
+                const open = pending.get(part.id) ?? [];
+                if (open.length > 1) ambiguousCalls.add(part.id);
+                const key =
+                    (part.kind === "tool_result"
+                        ? resultRun?.callId === part.id
+                            ? resultRun.key
+                            : (open.at(-1) ?? resolved.get(part.id))
+                        : undefined) ?? makeToolCompositeKey(message.info.id ?? "", part.id);
+                if (part.kind === "tool_use") open.push(key);
+                else {
+                    const position = open.lastIndexOf(key);
+                    if (position >= 0) open.splice(position, 1);
+                    resultRun = { callId: part.id, key };
+                    resolved.set(part.id, key);
+                }
+                pending.set(part.id, open);
+                let aggregate = aggregates.get(key);
+                if (!aggregate) {
+                    aggregate = {
+                        tag: tools.get(key),
+                        occurrences: [],
+                        reasoning: false,
+                    };
+                    aggregates.set(key, aggregate);
+                }
+                aggregate.occurrences.push({ message, part, kind: part.kind });
+                aggregate.reasoning ||= reasoning;
+            }
+        }
+    }
+    const arcsByCall = new Map<string, number>();
+    for (const { occurrences } of aggregates.values()) {
+        const callId = occurrences[0]?.part.id ?? "";
+        arcsByCall.set(callId, (arcsByCall.get(callId) ?? 0) + 1);
+    }
+    for (const aggregate of aggregates.values()) {
+        const { occurrences, reasoning } = aggregate;
+        const callId = occurrences[0]?.part.id ?? "";
+        if (ambiguousCalls.has(callId)) continue;
+        const tag =
+            aggregate.tag ??
+            (arcsByCall.get(callId) === 1
+                ? tools.get(makeToolCompositeKey("", callId))
+                : undefined);
+        if (tag)
+            targets.set(
+                tag.tagNumber,
+                buildAggregateTarget(tag.tagNumber, occurrences, reasoning, end),
+            );
+    }
+    if (!options.allowReasoningPrefixRewrite) {
+        // This target builder cannot persist removal of thinking. By default,
+        // withhold edits before reasoning rather than invalidate its signature.
+        // The Pi recovery handler opts in only to test edits on a saved copy;
+        // it must compare final request prefixes and refuse unsafe changes.
+        let lastThinking = -1;
+        transcript.messages.forEach((message, index) => {
+            if (message.parts.some((part) => part.kind === "thinking")) lastThinking = index;
+        });
+        const protectedIds = new Set(
+            transcript.messages.slice(0, lastThinking + 1).map((message) => message.info.id),
+        );
+        for (const [number, target] of targets) {
+            if (target.mutationParts?.some(({ message }) => protectedIds.has(message.info.id)))
+                targets.delete(number);
+        }
+    }
+    return targets;
+}
+
 /**
  * Tag eligible parts of a transcript and build TagTargets for them.
  *
@@ -1289,6 +1406,7 @@ function buildAggregateTarget(
             return any ? "truncated" : "absent";
         },
         // Open invocations still belong to the current turn; only complete arcs reclaim.
+        prepareDrop: () => !occurrences.some((occ) => occ.part.canRemove?.() === "defer"),
         canDrop: () => complete() && !occurrences.some((occ) => occ.part.hasUserAnswer?.()),
         requiresToolArcSkeleton,
         // Non-mutating read of the invocation input (the tool_use occurrence