@adhd/backlog 0.1.4 → 0.1.5

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adhd/backlog",
-  "version": "0.1.4",
+  "version": "0.1.5",
   "bin": {
     "backlog": "index.js"
   },
@@ -13,10 +13,11 @@
     "@adhd/apigen-plugin-ir-cache": "^0.1.0",
     "@adhd/apigen-plugin-mcp": "^0.2.3",
     "@adhd/apigen-plugin-openapi": "^0.2.2",
-    "@adhd/environment": "^0.1.3",
+    "@adhd/environment": "^0.1.5",
     "@adhd/environment-base-spec": "^0.1.0",
-    "@adhd/sox-graph-store": "^0.3.0",
-    "better-sqlite3": "^12.10.0",
+    "@adhd/sox-graph-store": "^0.8.3",
+    "@adhd/sox-store-adapter": "^0.5.7",
+    "@adhd/sox-telemetry": "^0.2.0",
     "pino": "10.3.1",
     "pino-pretty": "13.1.3",
     "yaml": "1.10.3"

package/server.d.ts

@@ -60,7 +60,7 @@ export interface StartOpts {
  * and never touch `ctx` at all, so a lazy caller can defer opening the real
  * backing store until a command that actually needs it is dispatched.
  */
-export declare function buildBacklogApigenPackage(ctx: BacklogCtx | (() => BacklogCtx)): Promise<{
+export declare function buildBacklogApigenPackage(ctx: BacklogCtx | (() => BacklogCtx | Promise<BacklogCtx>)): Promise<{
     pkg: {
         id: string;
         schemas: ReturnType<typeof composeSchemas>;

package/store/audit-log.d.ts

@@ -10,7 +10,7 @@ export declare const BACKLOG_AUDIT_EVENT_TAG = "backlog-audit-event";
  * byte-identical events (e.g. two items independently transitioning
  * `OPEN`→`IN_PROGRESS` with no `by`/`reason` at all) into ONE node.
  */
-export declare function writeAuditEvent(store: GraphBacklogStore, itemNodeId: number, repo: string, humanId: string, kind: AuditTrailEntry['kind'], detail: Record<string, unknown>): void;
+export declare function writeAuditEvent(store: GraphBacklogStore, itemNodeId: number, repo: string, humanId: string, kind: AuditTrailEntry['kind'], detail: Record<string, unknown>): Promise<void>;
 /** Every persisted event for `itemNodeId`, oldest first — ready to merge
  *  straight into `auditTrail()`'s `history` array. */
-export declare function queryAuditEvents(store: GraphBacklogStore, itemNodeId: number): AuditTrailEntry[];
+export declare function queryAuditEvents(store: GraphBacklogStore, itemNodeId: number): Promise<AuditTrailEntry[]>;

package/store/claim.d.ts

@@ -15,10 +15,10 @@ export declare class ClaimContentionError extends Error {
  *   by !== claimedBy, age >  staleAfterMin -> reclaimed-stale
  *   by !== claimedBy, opts.force           -> proceeds anyway (reclaimed-stale-shaped)
  */
-export declare function claimItemNode(store: GraphBacklogStore, nodeId: number, by: string, opts?: ClaimOpts): ClaimResult;
+export declare function claimItemNode(store: GraphBacklogStore, nodeId: number, by: string, opts?: ClaimOpts): Promise<ClaimResult>;
 /** SPEC.md §5.3 — "always succeeds (bumps claimedAt), no contention check, ever." */
-export declare function renewClaimNode(store: GraphBacklogStore, nodeId: number, by: string): ClaimResult;
+export declare function renewClaimNode(store: GraphBacklogStore, nodeId: number, by: string): Promise<ClaimResult>;
 /** DESIGN.md §4.2 — releasing an already-unclaimed item is a no-op, never an error. */
 export declare function releaseClaimNode(store: GraphBacklogStore, nodeId: number, by: string, opts?: {
     force?: boolean;
-}): ReleaseResult;
+}): Promise<ReleaseResult>;

package/store/crud.d.ts

@@ -34,9 +34,9 @@ import { BacklogItem, CreateItemInput, CreateItemResult, UpdateItemInput } from
  * exactly the false-positive shape this bug reports and must NOT pass.
  */
 export declare const TITLE_OVERLAP_MIN_FRACTION = 0.5;
-declare function dedupeScan(store: GraphBacklogStore, repo: string, input: CreateItemInput): BacklogItem[];
-export declare function createItemNode(store: GraphBacklogStore, input: CreateItemInput): CreateItemResult;
-export declare function getItemNode(store: GraphBacklogStore, repo: string, humanId: string): BacklogItem | null;
+declare function dedupeScan(store: GraphBacklogStore, repo: string, input: CreateItemInput): Promise<BacklogItem[]>;
+export declare function createItemNode(store: GraphBacklogStore, input: CreateItemInput): Promise<CreateItemResult>;
+export declare function getItemNode(store: GraphBacklogStore, repo: string, humanId: string): Promise<BacklogItem | null>;
 /**
  * DEVIATION (mitigated — DEBT-BACKLOG-CONTENT-IMMUTABLE-001): `@adhd/sox-graph-store`
  * exposes no PUBLIC primitive to update a node's `content` column after
@@ -46,15 +46,17 @@ export declare function getItemNode(store: GraphBacklogStore, repo: string, huma
  * column (source of truth for the API) AND `metadata.title`; `body` updates
  * `metadata.body` (source of truth for the API). Below, a title/body change
  * ALSO re-synchronizes the FTS-indexed `content`/`content_hash` columns
- * directly via raw SQL on the store-owned `db` handle — the same DESIGN.md
- * §14-sanctioned escape hatch `structure.ts`'s `removeDependencyNode` already
- * uses for the one other gap (`edge` deletion) the `GraphBackend` API lacks.
+ * directly via `adapter.executeRun` on the store-owned `adapter` handle —
+ * the same DESIGN.md §14-sanctioned escape hatch `structure.ts`'s
+ * `removeDependencyNode` already uses for the one other gap (`edge`
+ * deletion) the `GraphBackend` API lacks, now routed through the store-
+ * adapter's query surface (F-01/F-02: the raw `store.db` handle is gone).
  * This is safe specifically because `fts_node_au` (the real schema's `AFTER
  * UPDATE ON node` trigger — `~/dev/ai/sox-ecosystem/libs/data/graph/graph-store/
  * src/index.ts`'s `FTS_TRIGGERS`) re-indexes `fts_node` automatically on
  * ANY write to `node.content`/`name`/`summary`, so no separate FTS statement
  * is needed here.
  */
-export declare function updateItemNode(store: GraphBacklogStore, repo: string, humanId: string, patch: UpdateItemInput): BacklogItem;
-export declare function softDeleteItemNode(store: GraphBacklogStore, repo: string, humanId: string, reason: string): void;
+export declare function updateItemNode(store: GraphBacklogStore, repo: string, humanId: string, patch: UpdateItemInput): Promise<BacklogItem>;
+export declare function softDeleteItemNode(store: GraphBacklogStore, repo: string, humanId: string, reason: string): Promise<void>;
 export { dedupeScan };

package/store/graph-backlog-store.d.ts

@@ -1,20 +1,36 @@
 import { GraphBackend } from '@adhd/sox-graph-store';
-import { default as Database } from 'better-sqlite3';
+import { StoreAdapter } from '@adhd/sox-store-adapter';
 
 export interface GraphBacklogStore {
-    /** Raw handle — ONLY for the CAS transaction wrapper (mutate-metadata.ts / ids.ts). */
-    readonly db: Database.Database;
+    /** Store-adapter handle — ONLY for the CAS transaction wrapper (mutate-metadata.ts / ids.ts). */
+    readonly adapter: StoreAdapter;
     /** All non-CAS reads/writes go through this. */
     readonly graph: GraphBackend;
 }
 /**
  * @param busyTimeoutMs SQLite `busy_timeout` (ms) — how long a blocked
- *   `.immediate()` waits for a contended lock before throwing `SQLITE_BUSY`
- *   (DEBT-BACKLOG-CONCURRENCY-BUSY-RETRY-001). Callers reading from
- *   `BacklogConfig` should pass `env.config.db.busyTimeoutMs`; the default
- *   here (5000) matches that config field's own default, for callers (tests,
- *   ad-hoc scripts) that open a store directly without going through
- *   `buildBacklogEnv`.
+ *   `.transaction(fn, { mode: 'immediate' })` waits for a contended lock
+ *   before throwing `SQLITE_BUSY` (DEBT-BACKLOG-CONCURRENCY-BUSY-RETRY-001).
+ *   BUG-SOXGRAPH-002 moved busy_timeout ownership OUT of graph-store into the
+ *   adapters (SqliteAdapter hardcodes 3000 at connect; graph-store's
+ *   `PRAGMAS` no longer touches it), and `AdapterConfig` exposes no
+ *   busy_timeout field — so the caller's value is routed through the
+ *   adapter's own `pragmaSet('busy_timeout', N)` surface, which both
+ *   adapters honor (verified: read-back works on turso and sqlite). Callers
+ *   reading from `BacklogConfig` should pass `env.config.db.busyTimeoutMs`;
+ *   the default here (5000) matches that config field's own default, for
+ *   callers (tests, ad-hoc scripts) that open a store directly without going
+ *   through `buildBacklogEnv`.
  */
-export declare function openGraphBacklogStore(dbPath: string, busyTimeoutMs?: number): GraphBacklogStore;
-export declare function closeGraphBacklogStore(store: GraphBacklogStore): void;
+export declare function openGraphBacklogStore(dbPath: string, busyTimeoutMs?: number): Promise<GraphBacklogStore>;
+export declare function closeGraphBacklogStore(store: GraphBacklogStore): Promise<void>;
+/**
+ * Best-effort close for teardown finally-paths (cli.ts / server.ts).
+ * closeGraphBacklogStore may throw only in the extreme edge where the
+ * driver's own db.close() fails (every checkpoint/verify failure is already
+ * caught and logged inside the adapter — turso-adapter close()). On that edge
+ * this logs and returns so a close failure can never mask a command/transport
+ * error or turn a successful command into a failed exit. The adapter's own
+ * logs are the durable record; the client never rethrows here.
+ */
+export declare function closeGraphBacklogStoreSafe(store: GraphBacklogStore | undefined): Promise<void>;

package/store/ids.d.ts

@@ -12,7 +12,7 @@ import { NodeRecord } from '@adhd/sox-graph-store';
  * short-circuit on a non-null `existing` exactly like `createItemNode`'s
  * documented idempotent-reimport behavior, but now race-free.
  */
-export declare function allocateHumanIdAndInsert<T>(store: GraphBacklogStore, repo: string, family: string, idOverride: string | undefined, insert: (humanId: string, existing: NodeRecord | null) => T): T;
+export declare function allocateHumanIdAndInsert<T>(store: GraphBacklogStore, repo: string, family: string, idOverride: string | undefined, insert: (humanId: string, existing: NodeRecord | null) => T): Promise<T>;
 /**
  * @deprecated kept ONLY as a standalone id-generator for any caller that does
  * not need an atomic insert alongside it. `createItemNode`/
@@ -21,4 +21,4 @@ export declare function allocateHumanIdAndInsert<T>(store: GraphBacklogStore, re
  * concurrency). Still correct in isolation — just NOT TOCTOU-safe when the
  * caller's own insert happens in a separate, later transaction.
  */
-export declare function allocateHumanId(store: GraphBacklogStore, repo: string, family: string): string;
+export declare function allocateHumanId(store: GraphBacklogStore, repo: string, family: string): Promise<string>;

package/store/immediate-retry.d.ts

@@ -1,27 +1,32 @@
 /**
  * immediate-retry.ts — bounded, jittered exponential-backoff retry wrapper
- * around a `db.transaction(fn).immediate()` call (DEBT-BACKLOG-CONCURRENCY-
- * BUSY-RETRY-001). `mutate-metadata.ts` / `ids.ts` are the ONLY two write
- * paths that call `.immediate()` directly (DESIGN.md §3/§4.3) and both funnel
- * through this wrapper — retrying ONLY the specific `SQLITE_BUSY`/
- * `SQLITE_BUSY_TIMEOUT`/`SQLITE_BUSY_SNAPSHOT` error `better-sqlite3` throws
- * when a `BEGIN IMMEDIATE`'s wait exceeds `busy_timeout`. Any other thrown
- * error (including `NotFoundError`, `ClaimContentionError`) propagates
- * immediately, unretried — and the semantic `'held'` claim-contention RESULT
- * (claim.ts) is a normal RETURN VALUE, never an exception, so it is never
- * touched by this wrapper either.
+ * around `adapter.transaction(fn, { mode: 'immediate' })` (DEBT-BACKLOG-
+ * CONCURRENCY-BUSY-RETRY-001). `mutate-metadata.ts` / `ids.ts` are the ONLY
+ * two write paths that call `.immediate()` directly (DESIGN.md §3/§4.3) and
+ * both funnel through this wrapper — retrying ONLY busy-shaped errors, using
+ * store-adapter's portable `isBusyError`/`isConcurrentConflict` duck-type
+ * checks (the same helpers the adapter's own retry loop uses) so BOTH
+ * adapter error shapes are covered: the legacy SQLite adapter's
+ * `SQLITE_BUSY`/`SQLITE_BUSY_SNAPSHOT` codes and the turso driver's
+ * `GenericFailure` with a
+ * "database is locked"/"database is busy" message. Any other thrown error
+ * (including `NotFoundError`, `ClaimContentionError`) propagates immediately,
+ * unretried — and the semantic `'held'` claim-contention RESULT (claim.ts) is
+ * a normal RETURN VALUE, never an exception, so it is never touched by this
+ * wrapper either.
  */
 export interface ImmediateRetryOpts {
     /** Total attempts (first try + retries). Default 5. */
     maxAttempts?: number;
 }
 /**
- * Runs `attempt()` (expected to be `() => db.transaction(fn).immediate()`),
- * retrying up to `maxAttempts` times ONLY when it throws a SQLITE_BUSY-shaped
- * error, with jittered exponential backoff between attempts (20ms, 40ms,
- * 80ms, 160ms, capped at 500ms). Any other error propagates immediately.
- * After the final attempt still fails, the last SQLITE_BUSY error is
- * re-thrown (a genuine, sustained pileup is still a real failure — this
- * bounds the wait, it doesn't hide contention forever).
+ * Runs `attempt()` (expected to be
+ * `() => adapter.transaction(fn, { mode: 'immediate' })`), retrying up to
+ * `maxAttempts` times ONLY when it throws a busy-shaped error, with jittered
+ * exponential backoff between attempts (20ms, 40ms, 80ms, 160ms, capped at
+ * 500ms). Any other error propagates immediately. After the final attempt
+ * still fails, the last busy error is re-thrown (a genuine, sustained pileup
+ * is still a real failure — this bounds the wait, it doesn't hide contention
+ * forever).
  */
-export declare function withImmediateRetry<T>(attempt: () => T, opts?: ImmediateRetryOpts): T;
+export declare function withImmediateRetry<T>(attempt: () => Promise<T>, opts?: ImmediateRetryOpts): Promise<T>;

package/store/lifecycle.d.ts

@@ -1,18 +1,18 @@
 import { GraphBacklogStore } from './graph-backlog-store.js';
 import { ArchiveOpts, BacklogItem, BacklogStatus, Citation, StatsScope, TransitionOpts } from '../model.js';
 
-export declare function transitionStatusNode(store: GraphBacklogStore, repo: string, humanId: string, status: BacklogStatus, opts: TransitionOpts): BacklogItem;
+export declare function transitionStatusNode(store: GraphBacklogStore, repo: string, humanId: string, status: BacklogStatus, opts: TransitionOpts): Promise<BacklogItem>;
 /** Sugar for transitionStatus into any terminal status (SPEC.md §5.4). */
-export declare function resolveItemNode(store: GraphBacklogStore, repo: string, humanId: string, status: BacklogStatus, opts: TransitionOpts): BacklogItem;
+export declare function resolveItemNode(store: GraphBacklogStore, repo: string, humanId: string, status: BacklogStatus, opts: TransitionOpts): Promise<BacklogItem>;
 /**
  * `transitionStatus(id, 'IN_PROGRESS', ...)` + an implicit `claimItem(id, by)`.
  * If the item is actively claimed (not stale) by someone else, the claim
  * step returns `held` and startWork refuses — starting work on a
  * contended item would silently override the claim protocol otherwise.
  */
-export declare function startWorkNode(store: GraphBacklogStore, repo: string, humanId: string, by: string): BacklogItem;
-export declare function addCitationNode(store: GraphBacklogStore, repo: string, humanId: string, citation: Citation): BacklogItem;
-export declare function appendNoteNode(store: GraphBacklogStore, repo: string, humanId: string, by: string, text: string): BacklogItem;
+export declare function startWorkNode(store: GraphBacklogStore, repo: string, humanId: string, by: string): Promise<BacklogItem>;
+export declare function addCitationNode(store: GraphBacklogStore, repo: string, humanId: string, citation: Citation): Promise<BacklogItem>;
+export declare function appendNoteNode(store: GraphBacklogStore, repo: string, humanId: string, by: string, text: string): Promise<BacklogItem>;
 /**
  * Marks every terminal, non-excluded item in scope as archived
  * (`metadata.archivedAt`) and returns them — the graph node itself is NEVER
@@ -20,4 +20,4 @@ export declare function appendNoteNode(store: GraphBacklogStore, repo: string, h
  * CHANGELOG.md-formatted markdown is `client.ts`'s job (via `markdown.ts`) —
  * store/* never depends on markdown.ts (DESIGN.md §1 layering).
  */
-export declare function archiveTerminalItems(store: GraphBacklogStore, scope: StatsScope, opts?: ArchiveOpts): BacklogItem[];
+export declare function archiveTerminalItems(store: GraphBacklogStore, scope: StatsScope, opts?: ArchiveOpts): Promise<BacklogItem[]>;

package/store/mutate-metadata.d.ts

@@ -5,4 +5,4 @@ export declare class NotFoundError extends Error {
     readonly nodeId: number;
     constructor(nodeId: number);
 }
-export declare function mutateMetadata<M = BacklogNodeMeta>(store: GraphBacklogStore, nodeId: number, updater: (current: M) => M): M;
+export declare function mutateMetadata<M = BacklogNodeMeta>(store: GraphBacklogStore, nodeId: number, updater: (current: M) => M): Promise<M>;

package/store/query.d.ts

@@ -4,8 +4,8 @@ import { AuditTrailResult, BacklogFilter, BacklogItem, DependencyGraph, StatsSco
 import { NodeRecord } from '@adhd/sox-graph-store';
 
 /** Raw NodeRecord query — used internally where the full node (not just the mapped BacklogItem) is needed. */
-export declare function queryItemNodes(store: GraphBacklogStore, filter?: BacklogFilter): NodeRecord[];
-export declare function listItems(store: GraphBacklogStore, filter?: BacklogFilter): BacklogItem[];
+export declare function queryItemNodes(store: GraphBacklogStore, filter?: BacklogFilter): Promise<NodeRecord[]>;
+export declare function listItems(store: GraphBacklogStore, filter?: BacklogFilter): Promise<BacklogItem[]>;
 /**
  * BUG-BACKLOG-HUMANID-COLLISION-001 fix #2: this is THE shared `(repo,
  * humanId) -> NodeRecord` lookup every store module funnels through
@@ -20,7 +20,7 @@ export declare function listItems(store: GraphBacklogStore, filter?: BacklogFilt
  * that finds >1 live match now throws `AmbiguousHumanIdError` instead of
  * guessing.
  */
-export declare function findItemNode(store: GraphBacklogStore, repo: string, humanId: string): NodeRecord | null;
+export declare function findItemNode(store: GraphBacklogStore, repo: string, humanId: string): Promise<NodeRecord | null>;
 /**
  * Finds every LIVE node carrying this `humanId`, across ALL repos (no
  * `namespace` filter) — BUG-BACKLOG-REPO-LOOKUP-UX-001's "did you mean repo
@@ -29,7 +29,7 @@ export declare function findItemNode(store: GraphBacklogStore, repo: string, hum
  * passed." Used only on the miss path (`buildNotFoundError`) — never on the
  * hot successful-lookup path, so it costs nothing when a lookup is correct.
  */
-export declare function findHumanIdInAnyRepo(store: GraphBacklogStore, humanId: string): NodeRecord[];
+export declare function findHumanIdInAnyRepo(store: GraphBacklogStore, humanId: string): Promise<NodeRecord[]>;
 /**
  * Every distinct repo value any LIVE backlog item is currently filed under.
  * Used by `createItemNode`'s soft repo-drift warning (write-time half of
@@ -37,7 +37,7 @@ export declare function findHumanIdInAnyRepo(store: GraphBacklogStore, humanId:
  * "known" repos, so the very first item filed under any repo string never
  * triggers a false-positive warning.
  */
-export declare function knownRepos(store: GraphBacklogStore): Set<string>;
+export declare function knownRepos(store: GraphBacklogStore): Promise<Set<string>>;
 /**
  * Builds the `BacklogItemNotFoundError` every miss site throws — the single
  * place that decides whether a "did you mean repo X?" hint is warranted
@@ -46,14 +46,14 @@ export declare function knownRepos(store: GraphBacklogStore): Set<string>;
  * re-queries WITHOUT the `namespace` restriction to see if the humanId lives
  * under a different repo string instead.
  */
-export declare function buildNotFoundError(store: GraphBacklogStore, repo: string, humanId: string): BacklogItemNotFoundError;
-export declare function computeStats(store: GraphBacklogStore, scope?: StatsScope): import('../model.js').BacklogStats;
-export declare function spotlight(store: GraphBacklogStore, scope?: StatsScope, limit?: number): BacklogItem[];
-export declare function blockers(store: GraphBacklogStore, repo: string, humanId: string): BacklogItem[];
-export declare function readyItems(store: GraphBacklogStore, scope?: StatsScope): BacklogItem[];
-export declare function dependencyGraph(store: GraphBacklogStore, scope?: StatsScope): DependencyGraph;
-export declare function topoOrder(store: GraphBacklogStore, scope?: StatsScope): TopoOrderResult;
-export declare function staleClaims(store: GraphBacklogStore, maxAgeMin: number, scope?: StatsScope): BacklogItem[];
+export declare function buildNotFoundError(store: GraphBacklogStore, repo: string, humanId: string): Promise<BacklogItemNotFoundError>;
+export declare function computeStats(store: GraphBacklogStore, scope?: StatsScope): Promise<import('../model.js').BacklogStats>;
+export declare function spotlight(store: GraphBacklogStore, scope?: StatsScope, limit?: number): Promise<BacklogItem[]>;
+export declare function blockers(store: GraphBacklogStore, repo: string, humanId: string): Promise<BacklogItem[]>;
+export declare function readyItems(store: GraphBacklogStore, scope?: StatsScope): Promise<BacklogItem[]>;
+export declare function dependencyGraph(store: GraphBacklogStore, scope?: StatsScope): Promise<DependencyGraph>;
+export declare function topoOrder(store: GraphBacklogStore, scope?: StatsScope): Promise<TopoOrderResult>;
+export declare function staleClaims(store: GraphBacklogStore, maxAgeMin: number, scope?: StatsScope): Promise<BacklogItem[]>;
 /**
  * Bi-temporal history + supersession chain (SPEC.md §5.6, DESIGN.md §2.3).
  * DEVIATION: the store does not persist a full mutation event log (no
@@ -64,5 +64,5 @@ export declare function staleClaims(store: GraphBacklogStore, maxAgeMin: number,
  * `item.updatedAt` as their timestamp since `Citation` carries no `at` field
  * of its own. Filed as DEBT-BACKLOG-AUDIT-TRAIL-PARTIAL-001.
  */
-export declare function auditTrail(store: GraphBacklogStore, repo: string, humanId: string): AuditTrailResult;
+export declare function auditTrail(store: GraphBacklogStore, repo: string, humanId: string): Promise<AuditTrailResult>;
 export type { BacklogNodeMeta };

package/store/structure.d.ts

@@ -1,16 +1,18 @@
 import { GraphBacklogStore } from './graph-backlog-store.js';
 import { BacklogItem, CreateItemInput, Priority } from '../model.js';
 
-export declare function addDependencyNode(store: GraphBacklogStore, repo: string, humanId: string, dependsOnHumanId: string): void;
+export declare function addDependencyNode(store: GraphBacklogStore, repo: string, humanId: string, dependsOnHumanId: string): Promise<void>;
 /**
  * `@adhd/sox-graph-store` exposes no edge-delete primitive (only
  * `invalidate()` for nodes, bi-temporal) — DESIGN.md §14 explicitly sanctions
- * a raw `DELETE` on the store-owned `db` handle as the one place the adapter
+ * a raw `DELETE` on the store-owned handle as the one place the adapter
  * reaches past the `GraphBackend` API, confirmed against the real `edge`
- * table column names (`src`/`dst`/`rel`).
+ * table column names (`src`/`dst`/`rel`). F-01/F-02: routed through the
+ * store-adapter's `executeRun` query surface (the raw `store.db` handle is
+ * gone) — same SQL, same semantics.
  */
-export declare function removeDependencyNode(store: GraphBacklogStore, repo: string, humanId: string, dependsOnHumanId: string): void;
-export declare function linkRelatedNode(store: GraphBacklogStore, repo: string, humanIdA: string, humanIdB: string): void;
+export declare function removeDependencyNode(store: GraphBacklogStore, repo: string, humanId: string, dependsOnHumanId: string): Promise<void>;
+export declare function linkRelatedNode(store: GraphBacklogStore, repo: string, humanIdA: string, humanIdB: string): Promise<void>;
 /**
  * DESIGN.md §14 point 2 (CONFIRMED against the real source): `supersede(oldId,
  * newContent, meta)` writes `SUPERSEDES` new -> old, sets `is_superseded=1`
@@ -21,18 +23,18 @@ export declare function linkRelatedNode(store: GraphBacklogStore, repo: string,
  * invalidation — `touch()`/`mutateMetadata` throw once `t_invalid` is set)
  * and a final `invalidate(oldId, reason)`.
  */
-export declare function supersedeItemNode(store: GraphBacklogStore, repo: string, oldHumanId: string, newInput: CreateItemInput, reason: string): BacklogItem;
+export declare function supersedeItemNode(store: GraphBacklogStore, repo: string, oldHumanId: string, newInput: CreateItemInput, reason: string): Promise<BacklogItem>;
 /** Creates N children, each linked child PART_OF parent. Parent is left open. */
-export declare function splitItemNode(store: GraphBacklogStore, repo: string, parentHumanId: string, children: CreateItemInput[]): BacklogItem[];
+export declare function splitItemNode(store: GraphBacklogStore, repo: string, parentHumanId: string, children: CreateItemInput[]): Promise<BacklogItem[]>;
 /**
  * `SAME_AS(drop -> keep)` per DESIGN.md §14 point 2 (obsolete -> canonical,
  * matching the `supersede()` convention), then `invalidate(drop, reason)`.
  * Returns the KEPT item.
  */
-export declare function mergeItemsNode(store: GraphBacklogStore, repo: string, keepHumanId: string, dropHumanId: string, reason: string): BacklogItem;
-export declare function setPriorityNode(store: GraphBacklogStore, repo: string, humanId: string, priority: Priority): BacklogItem;
-export declare function attachToPlanNode(store: GraphBacklogStore, repo: string, humanId: string, planSlug: string): void;
-export declare function assignItemNode(store: GraphBacklogStore, repo: string, humanId: string, to: string, by: string): BacklogItem;
+export declare function mergeItemsNode(store: GraphBacklogStore, repo: string, keepHumanId: string, dropHumanId: string, reason: string): Promise<BacklogItem>;
+export declare function setPriorityNode(store: GraphBacklogStore, repo: string, humanId: string, priority: Priority): Promise<BacklogItem>;
+export declare function attachToPlanNode(store: GraphBacklogStore, repo: string, humanId: string, planSlug: string): Promise<void>;
+export declare function assignItemNode(store: GraphBacklogStore, repo: string, humanId: string, to: string, by: string): Promise<BacklogItem>;
 /**
  * BUG-BACKLOG-HUMANID-COLLISION-001 fix #3 (repair primitive): re-ids a
  * single, `nodeId`-scoped live backlog item to a new `humanId` within the
@@ -61,4 +63,4 @@ export declare function assignItemNode(store: GraphBacklogStore, repo: string, h
  *    `buildNodeContent`) so the renamed node is indistinguishable from one
  *    that was always minted under `newHumanId`.
  */
-export declare function renameHumanIdNode(store: GraphBacklogStore, repo: string, nodeId: number, oldHumanId: string, newHumanId: string): BacklogItem;
+export declare function renameHumanIdNode(store: GraphBacklogStore, repo: string, nodeId: number, oldHumanId: string, newHumanId: string): Promise<BacklogItem>;