feat(core): log SQLite write-lock holds and lock-stop call sites

CHANGESET.md

@@ -69,6 +69,11 @@ Newest first. Each entry names the upstream range brought in.
 
 ### Runtime fixes
 
+- **#201** Log SQLite write-lock holds and lock-stop call sites, diagnostics only (firstmate task
+  opencode-stop-instrument-180, follows #194): an immediate transaction holding the write lock over 250 ms logs its
+  pid, purpose and duration; a lock failure leaving the retry gate logs one summary with the statement head, attempts,
+  elapsed time and native code; and halt's error line names the failed write's event, stream case and call site. No
+  behaviour changes. _Fork-only._
 - **#194** Fix dropped accepted prompts under concurrent SQLite writers (swxtchio/swx-opencode#162, #165): queue writes begin with BEGIN IMMEDIATE, so a write waits on the lock instead of failing on a snapshot pinned by an earlier read, and the busy-retry gate has one owner in effect-sqlite-node/src/retry.ts. Queue writes on the consumption path use the same lock, which is beyond #167's scope. _Fork-only._
 - **#163** Revert #155 (swxtchio/swx-opencode#153): under concurrent writers it dropped more accepted prompts than its parent #150, so the busy waits return to the pre-#155 schedule. The fix-forward is tracked in swxtchio/swx-opencode#162. _Fork-only._
 - **#144** Make `opencode db path` print the selected path without initializing `AppRuntime` or SQLite, defer global directory creation to runtime initialization, and preserve explicit and channel-specific database path selection. _Upstreamable._

packages/core/src/database/sqlite.bun.ts

@@ -83,7 +83,7 @@ const make = (options: Config) =>
           try: () => (statement.all(...(params as any)) ?? []) as Array<Record<string, unknown>>,
           catch: statementError,
         })
-        return retryLocked(execute)
+        return retryLocked(execute, query)
       })
 
     const runValues = (query: string, params: ReadonlyArray<unknown> = []) =>
@@ -95,7 +95,7 @@ const make = (options: Config) =>
           try: () => (statement.values(...(params as any)) ?? []) as Array<unknown[]>,
           catch: statementError,
         })
-        return retryLocked(execute)
+        return retryLocked(execute, query)
       })
 
     const connection = identity<SqliteConnection>({

packages/core/src/database/sqlite.node.ts

@@ -91,7 +91,7 @@ const make = (options: Config) =>
           try: () => statement.all(...(params as SQLInputValue[])) as Array<Record<string, unknown>>,
           catch: statementError,
         })
-        return retryLocked(execute)
+        return retryLocked(execute, query)
       })
 
     const runValues = (query: string, params: ReadonlyArray<unknown> = []) =>
@@ -103,7 +103,7 @@ const make = (options: Config) =>
           try: () => statement.all(...(params as SQLInputValue[])) as unknown as ReadonlyArray<ReadonlyArray<unknown>>,
           catch: statementError,
         })
-        return retryLocked(execute)
+        return retryLocked(execute, query)
       })
 
     const connection = identity<SqliteConnection>({

packages/core/src/event.ts

@@ -5,6 +5,8 @@ import { Event } from "@opencode-ai/schema/event"
 import type { Data, Definition, Payload } from "@opencode-ai/schema/event"
 import { and, asc, eq, gt, inArray } from "drizzle-orm"
 import { Database } from "./database/database"
+import { TransactionPurpose } from "@opencode-ai/effect-drizzle-sqlite"
+import { FailureOrigin } from "./observability/failure-origin"
 import { EventRetentionTable, EventSequenceTable, EventTable } from "./event/sql"
 import { Location } from "./location"
 import { makeGlobalNode } from "./effect/app-node"
@@ -466,7 +468,11 @@ export const layerWith = (options?: LayerOptions) =>
                         }),
                       { behavior: "immediate" },
                     )
-                    .pipe(Effect.orDie)
+                    .pipe(
+                      Effect.provideService(TransactionPurpose, definition.type),
+                      Effect.tapCause((cause) => FailureOrigin.record(cause, { event: definition.type })),
+                      Effect.orDie,
+                    )
                   if (committed) {
                     yield* Effect.forEach(
                       pubsub.durable.get(committed.aggregateID) ?? [],

packages/core/src/observability/failure-origin.ts

@@ -0,0 +1,41 @@
+import { Cause, Context, Effect } from "effect"
+
+// Where a failure came from, for diagnostics only. Keyed by the failure object, so the attribution follows that
+// failure through Cause squashing and later work cannot overwrite it; the failure itself is never changed.
+export type Origin = {
+  readonly event?: string
+  readonly stage?: "handler" | "stream"
+  readonly case?: string
+  readonly callSite?: string
+}
+
+const origins = new WeakMap<object, Origin>()
+
+// The innermost recording wins each field. The call site is the stack frame chain the runtime captured where the
+// failure was raised, so it names the failing callable even when it is recorded after those scopes have unwound or
+// across a stream boundary.
+export const record = (cause: Cause.Cause<unknown>, origin: Omit<Origin, "callSite">) =>
+  Effect.sync(() => {
+    if (Cause.hasInterruptsOnly(cause)) return
+    const failure = Cause.squash(cause)
+    if (typeof failure !== "object" || failure === null) return
+    const callSite = frameChain(cause)
+    origins.set(failure, { ...origin, ...(callSite && { callSite }), ...origins.get(failure) })
+  })
+
+export const get = (failure: unknown) =>
+  typeof failure === "object" && failure !== null ? origins.get(failure) : undefined
+
+function frameChain(cause: Cause.Cause<unknown>) {
+  const names: string[] = []
+  const captured = Context.getOption(Cause.annotations(cause), Cause.StackTrace)
+  let frame = captured._tag === "Some" ? captured.value : undefined
+  while (frame && names.length < 8) {
+    // Effect.fn records a definition-site frame beside each call frame; the call frames name the path.
+    if (!frame.name.endsWith(" (definition)")) names.push(frame.name)
+    frame = frame.parent
+  }
+  return names.length ? names.join(" < ") : undefined
+}
+
+export * as FailureOrigin from "./failure-origin"