@adhd/backlog 0.0.1

package/markdown.d.ts

@@ -0,0 +1,64 @@
+import { BacklogFilter, BacklogItem, BacklogStatus, Priority } from './model.js';
+
+declare const LEGACY_TERMINAL_DONE: string[];
+declare const LEGACY_TERMINAL_WORKAROUND: string[];
+declare const LEGACY_TERMINAL_DISMISSED: string[];
+declare const LEGACY_TERMINAL: Set<string>;
+export declare function normalizeLegacyStatus(rawLabel: string): BacklogStatus;
+/**
+ * Classify a free-form status string into a {label, open} pair — ported
+ * verbatim from tools/util/backlog.mjs:56-82 (`classifyStatus`). Backlog
+ * Status lines are prose, so an open signal must win over a closed word when
+ * both are present.
+ */
+export declare function classifyStatus(raw: string | undefined): {
+    label: string;
+    open: boolean;
+} | null;
+/** Ported verbatim from tools/util/backlog.mjs:84-96 (`detectStatus`). */
+export declare function detectStatus(headerLine: string, body: string): {
+    label: string;
+    open: boolean;
+};
+/** Ported verbatim from tools/util/backlog.mjs:98-104 (`detectPriority`). */
+export declare function detectPriority(headerLine: string, body: string): string;
+export interface ParsedMarkdownItem {
+    id: string;
+    kind: string;
+    family: string;
+    title: string;
+    level: number;
+    line: number;
+    headerLine: string;
+    status: string;
+    open: boolean;
+    terminal: boolean;
+    priority: string;
+    body: string;
+}
+/** Ported (structure preserved) from tools/util/backlog.mjs:106-155 (`parse`). */
+export declare function parseBacklogMarkdown(text: string): ParsedMarkdownItem[];
+/**
+ * SPEC.md §5.6 `renderToMarkdown` — one `###` block per item. Archived-item
+ * exclusion (SPEC.md §5.4 `archiveResolved`'s "renderToMarkdown's default
+ * view excludes them") happens one layer up, in `client.ts`'s
+ * `renderToMarkdown`, which has access to the raw node `metadata.archivedAt`
+ * flag — `BacklogItem` (SPEC.md §4.1) deliberately carries no `archivedAt`
+ * field of its own, so this function (pure, no store access) cannot filter
+ * on it and takes an already-filtered `items` array.
+ */
+export declare function renderItemsToMarkdown(items: BacklogItem[]): string;
+/** Ported from tools/util/backlog.mjs:351-361 (`buildChangelogSection`). */
+export declare function buildChangelogSection(items: BacklogItem[], date: string): string;
+/** Applies the SAME filters `applyFilters`/`BacklogFilter` describes, used only for markdown-side symmetry checks in tests. */
+export declare function matchesFilter(item: ParsedMarkdownItem, filter: BacklogFilter): boolean;
+export interface ParsedImportItem {
+    humanId: string;
+    title: string;
+    body: string;
+    status: BacklogStatus;
+    priority?: Priority;
+}
+/** Bridges the legacy parser's raw shape into the canonical vocabulary (SPEC.md §5.6 `importFromMarkdown`). */
+export declare function toImportItems(parsed: ParsedMarkdownItem[]): ParsedImportItem[];
+export { LEGACY_TERMINAL, LEGACY_TERMINAL_DONE, LEGACY_TERMINAL_DISMISSED, LEGACY_TERMINAL_WORKAROUND };

package/model.d.ts

@@ -0,0 +1,220 @@
+/**
+ * model.ts — the `BacklogItem` domain shape and every operation-surface input
+ * / output type. Ported verbatim from `SPEC.md` §4/§5. Pure types + a handful
+ * of tiny, dependency-free classification helpers — no store/env imports.
+ */
+export type BacklogStatus = 'OPEN' | 'IN_PROGRESS' | 'PARTIAL' | 'OUTSTANDING' | 'DEFERRED' | 'BLOCKED' | 'MIXED' | 'UNKNOWN' | 'FIXED' | 'RESOLVED' | 'DONE' | 'SHIPPED' | 'VERIFIED' | 'REMOVED' | 'MITIGATED' | 'SUPERSEDED' | 'INVALID' | 'DUPLICATE' | 'WONTFIX';
+/** §4.2 rule 3 — terminal-done + terminal-workaround: require ≥1 citation. */
+export declare const TERMINAL_DONE_STATUSES: ReadonlySet<BacklogStatus>;
+export declare const TERMINAL_WORKAROUND_STATUSES: ReadonlySet<BacklogStatus>;
+/** §4.2 rule 3 — terminal-dismissed: require a reason (citation optional). */
+export declare const TERMINAL_DISMISSED_STATUSES: ReadonlySet<BacklogStatus>;
+export declare const TERMINAL_STATUSES: ReadonlySet<BacklogStatus>;
+export declare function isTerminalStatus(status: BacklogStatus): boolean;
+/** §4.2 rule 3 — "a transition INTO any terminal status requires evidence." */
+export declare function requiresCitation(status: BacklogStatus): boolean;
+export declare function requiresReason(status: BacklogStatus): boolean;
+export type Priority = 'CRITICAL' | 'HIGH' | 'MEDIUM' | 'LOW';
+export interface Citation {
+    /** Repo-relative path, matching the global CLAUDE.md citation format. */
+    file: string;
+    /** e.g. "42-58"; omit for a whole-file citation. */
+    lines?: string;
+    /** Free text — active git context / agent name / model, per the citation format. */
+    context?: string;
+}
+export interface Note {
+    by: string;
+    at: string;
+    text: string;
+}
+export interface BacklogItem {
+    /** The graph node id (see DESIGN.md §2). Never exposed to markdown; internal only. */
+    nodeId: number;
+    /** Human-facing id, e.g. "BUG-APIGEN-014". Unique within (repo, family). */
+    humanId: string;
+    /** First hyphen segment of humanId, e.g. "BUG". Open vocabulary — not an enum. */
+    kind: string;
+    /** humanId with the trailing "-NNN" stripped, e.g. "BUG-APIGEN". */
+    family: string;
+    title: string;
+    /** Markdown body — the full entry text minus the header line. */
+    body: string;
+    status: BacklogStatus;
+    priority?: Priority;
+    /** Stable repo slug — see SPEC.md §3 "Repo identity". */
+    repo: string;
+    /** Package-relative path within the repo, e.g. "packages/apigen/apigen-core-client". Optional — repo-level items omit it. */
+    projectPath?: string;
+    /** Plan slug this item is attached to, if any — e.g. "agent-registry-schema". */
+    plan?: string;
+    /** Durable ownership — who this item is assigned to (may differ from the active claimant). */
+    assignee?: string;
+    /** Ephemeral claim lease — see SPEC.md §5. */
+    claimedBy?: string;
+    claimedAt?: string;
+    citations: Citation[];
+    notes: Note[];
+    tags: string[];
+    createdAt: string;
+    updatedAt: string;
+}
+export declare class BacklogItemNotFoundError extends Error {
+    constructor(repo: string, humanId: string);
+}
+export declare class CitationRequiredError extends Error {
+    constructor(status: BacklogStatus);
+}
+export declare class ReasonRequiredError extends Error {
+    constructor(status: BacklogStatus);
+}
+export declare class ClaimHeldError extends Error {
+    readonly heldBy: string;
+    readonly heldSince: string;
+    constructor(heldBy: string, heldSince: string);
+}
+export declare class DependencyCycleError extends Error {
+    readonly cycle: string[];
+    constructor(cycle: string[]);
+}
+export interface DedupeScanInput {
+    symbol?: string;
+    path?: string;
+    errorText?: string;
+}
+export interface CreateItemInput {
+    family: string;
+    idOverride?: string;
+    title: string;
+    body: string;
+    repo: string;
+    projectPath?: string;
+    priority?: Priority;
+    tags?: string[];
+    plan?: string;
+    dedupeScan?: DedupeScanInput;
+    /** Skip the dedupe gate and file anyway (planner override after reviewing candidates). */
+    force?: boolean;
+}
+export interface CreateItemResult {
+    item: BacklogItem;
+    created: boolean;
+    duplicateCandidates: BacklogItem[];
+}
+export interface UpdateItemInput {
+    title?: string;
+    body?: string;
+    tags?: string[];
+    projectPath?: string;
+}
+export interface BacklogFilter {
+    repo?: string;
+    projectPath?: string;
+    status?: BacklogStatus | 'open' | 'closed';
+    kind?: string;
+    family?: string;
+    priority?: Priority;
+    plan?: string;
+    assignee?: string;
+    claimedBy?: string;
+    tags?: string[];
+    grep?: string;
+    limit?: number;
+    offset?: number;
+}
+export interface StatsScope {
+    repo?: string;
+    projectPath?: string;
+}
+export interface BacklogStats {
+    total: number;
+    open: number;
+    closed: number;
+    byStatus: Record<string, number>;
+    byKind: Record<string, number>;
+    byFamily: Record<string, number>;
+    byPriority: Record<string, number>;
+    byRepo: Record<string, number>;
+}
+export interface DependencyGraph {
+    nodes: Array<{
+        humanId: string;
+        title: string;
+        status: BacklogStatus;
+    }>;
+    edges: Array<{
+        from: string;
+        to: string;
+        rel: 'DEPENDS_ON' | 'RELATES_TO' | 'PART_OF';
+    }>;
+}
+export type TopoOrderResult = {
+    ok: true;
+    order: string[];
+} | {
+    ok: false;
+    cycle: string[];
+};
+export interface ClaimOpts {
+    /** Minutes after which an unrenewed claim is considered abandoned. Default: 30 (DESIGN.md §4.2). */
+    staleAfterMin?: number;
+    /** Explicitly override a claim that is NOT stale (human-confirmed abandonment). */
+    force?: boolean;
+}
+export type ClaimStatus = 'claimed' | 'renewed' | 'reclaimed-stale' | 'held';
+export interface ClaimResult {
+    status: ClaimStatus;
+    claimedBy: string;
+    claimedAt: string;
+    /** Only present when status === 'held'. */
+    heldBy?: string;
+    heldSince?: string;
+    /** Only present when status === 'reclaimed-stale' — the abandoned claimant, for audit. */
+    previousClaimant?: string;
+}
+export interface ReleaseResult {
+    status: 'released' | 'release-noop';
+    wasClaimedBy?: string;
+}
+export interface TransitionOpts {
+    by: string;
+    note?: string;
+    citations?: Citation[];
+    reason?: string;
+}
+export interface ArchiveOpts {
+    /** Exclude specific humanIds from the sweep even though they're terminal (mirrors tools/util/backlog.mjs's --exclude). */
+    exclude?: string[];
+}
+export interface ArchiveResult {
+    archivedCount: number;
+    changelogMarkdown: string;
+}
+export interface ImportMarkdownInput {
+    path: string;
+    repo: string;
+    projectPath?: string;
+    dryRun?: boolean;
+}
+export interface ImportResult {
+    parsed: number;
+    created: number;
+    skippedDuplicates: number;
+    errors: Array<{
+        humanId: string;
+        message: string;
+    }>;
+}
+export interface AuditTrailEntry {
+    at: string;
+    kind: 'created' | 'transition' | 'claim' | 'note' | 'citation' | 'supersession';
+    detail: Record<string, unknown>;
+}
+export interface AuditTrailResult {
+    humanId: string;
+    history: AuditTrailEntry[];
+    supersessionChain?: {
+        supersedes?: string;
+        supersededBy?: string;
+    };
+}

package/package.json

@@ -0,0 +1,20 @@
+{
+  "name": "@adhd/backlog",
+  "version": "0.0.1",
+  "dependencies": {
+    "@adhd/sox-graph-store": "^0.3.0",
+    "better-sqlite3": "^12.10.0",
+    "@adhd/environment": "^0.0.2",
+    "@adhd/environment-base-spec": "^0.0.3",
+    "@adhd/apigen-core-client": "^0.1.2",
+    "@adhd/apigen-plugin-api-fastify": "^0.1.3",
+    "@adhd/apigen-plugin-openapi": "^0.1.4",
+    "@adhd/apigen-plugin-mcp": "^0.1.3"
+  },
+  "main": "./index.js",
+  "module": "./index.mjs",
+  "typings": "./index.d.ts",
+  "publishConfig": {
+    "access": "public"
+  }
+}

package/server.d.ts

@@ -0,0 +1,31 @@
+import { BacklogCtx } from './client.js';
+import { composeSchemas, Operation } from '@adhd/apigen-core-client';
+import { Scope } from '@adhd/environment-base-spec';
+
+export interface StartOpts {
+    transport: 'http' | 'mcp' | 'both';
+    port?: number;
+    host?: string;
+    scope?: Scope;
+    /** Test-only override — see `buildBacklogEnv`'s `BuildBacklogEnvOptions`. */
+    adhdRoot?: string;
+    cwd?: string;
+    signal: AbortSignal;
+}
+/** Builds the composed, apigen-ready package descriptor for `client.ts`'s exports. */
+export declare function buildBacklogApigenPackage(ctx: BacklogCtx): Promise<{
+    pkg: {
+        id: string;
+        schemas: ReturnType<typeof composeSchemas>;
+        importPath: string;
+        fns: Record<string, (...args: unknown[]) => unknown>;
+        createClient: () => Promise<BacklogCtx>;
+    };
+    operations: Operation[];
+}>;
+/**
+ * Opens (or reuses) the backlog store + env, mounts every `client.ts` export
+ * live via `@adhd/apigen-plugin-api-fastify` and/or `@adhd/apigen-plugin-mcp`
+ * — no code generation.
+ */
+export declare function startBacklogServer(opts: StartOpts): Promise<void>;

package/store/claim.d.ts

@@ -0,0 +1,24 @@
+import { GraphBacklogStore } from './graph-backlog-store.js';
+import { ClaimOpts, ClaimResult, ReleaseResult } from '../model.js';
+
+/** DESIGN.md §4.2 — matches STALE_CLAIM_S = 30*60 at state-transition.js:601. */
+export declare const DEFAULT_STALE_AFTER_MIN = 30;
+export declare class ClaimContentionError extends Error {
+    readonly heldBy: string;
+    constructor(heldBy: string, by: string);
+}
+/**
+ * DESIGN.md §4.2 — the exact branch table:
+ *   unclaimed                              -> claimed
+ *   by === claimedBy                       -> renewed (no contention check, ever)
+ *   by !== claimedBy, age <= staleAfterMin -> held (refuse, no write)
+ *   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;
+/** SPEC.md §5.3 — "always succeeds (bumps claimedAt), no contention check, ever." */
+export declare function renewClaimNode(store: GraphBacklogStore, nodeId: number, by: string): 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;

package/store/crud.d.ts

@@ -0,0 +1,20 @@
+import { GraphBacklogStore } from './graph-backlog-store.js';
+import { BacklogItem, CreateItemInput, CreateItemResult, UpdateItemInput } from '../model.js';
+
+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;
+/**
+ * DEVIATION: `@adhd/sox-graph-store` exposes no primitive to update a node's
+ * `content` column after creation (`touch()`'s `Partial<NodeMeta>` covers
+ * name/summary/topic/tags/importance/confidence/tExpires/metadata — never
+ * `content`; verified against the real source). `title` updates the `summary`
+ * column (source of truth for the API) AND `metadata.title`; `body` updates
+ * ONLY `metadata.body` (source of truth for the API). The underlying FTS
+ * `content` (set once at `createItem` time) therefore does not reflect a
+ * later body edit — `listItems({ grep })` may miss a post-edit body term
+ * until the item is superseded. Filed as DEBT-BACKLOG-CONTENT-IMMUTABLE-001.
+ */
+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 { dedupeScan };

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

@@ -0,0 +1,11 @@
+import { GraphBackend } from '@adhd/sox-graph-store';
+import { default as Database } from 'better-sqlite3';
+
+export interface GraphBacklogStore {
+    /** Raw handle — ONLY for the CAS transaction wrapper (mutate-metadata.ts / ids.ts). */
+    readonly db: Database.Database;
+    /** All non-CAS reads/writes go through this. */
+    readonly graph: GraphBackend;
+}
+export declare function openGraphBacklogStore(dbPath: string): GraphBacklogStore;
+export declare function closeGraphBacklogStore(store: GraphBacklogStore): void;

package/store/ids.d.ts

@@ -0,0 +1,3 @@
+import { GraphBacklogStore } from './graph-backlog-store.js';
+
+export declare function allocateHumanId(store: GraphBacklogStore, repo: string, family: string): string;

package/store/lifecycle.d.ts

@@ -0,0 +1,23 @@
+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;
+/** 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;
+/**
+ * `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;
+/**
+ * Marks every terminal, non-excluded item in scope as archived
+ * (`metadata.archivedAt`) and returns them — the graph node itself is NEVER
+ * deleted (bi-temporal history is permanent). Rendering the archived set to
+ * 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[];

package/store/mapping.d.ts

@@ -0,0 +1,49 @@
+import { BacklogItem, BacklogStatus, Citation, Note, Priority } from '../model.js';
+import { NodeRecord } from '@adhd/sox-graph-store';
+
+export declare const BACKLOG_ITEM_TAG = "backlog-item";
+export declare const BACKLOG_PLAN_TAG = "backlog-plan";
+export declare const BACKLOG_ASSIGNEE_TAG = "backlog-assignee";
+/**
+ * The JSON shape persisted in `node.meta` (DESIGN.md §2.2/§4.1). Every
+ * mutating store operation reads the CURRENT full object, computes a new
+ * COMPLETE object, and writes it back via `mutateMetadata` — `touch()`
+ * replaces `meta` wholesale (verified, DESIGN.md §14 point 4), so a partial
+ * write here would silently drop every other field.
+ */
+export interface BacklogNodeMeta {
+    humanId: string;
+    kind: string;
+    family: string;
+    title: string;
+    body: string;
+    status: BacklogStatus;
+    priority?: Priority;
+    repo: string;
+    projectPath?: string;
+    plan?: string;
+    assignee?: string;
+    claimedBy?: string;
+    claimedAt?: string;
+    citations: Citation[];
+    notes: Note[];
+    createdAt: string;
+    updatedAt: string;
+    /** Set by archiveResolved — excludes the item from renderToMarkdown's default view. */
+    archivedAt?: string;
+    /** Dedupe-scan exact-match fields (DESIGN.md §2.4). */
+    dedupeSymbol?: string;
+    dedupePath?: string;
+    dedupeErrorText?: string;
+}
+export declare function humanIdKind(humanId: string): string;
+export declare function humanIdFamily(humanId: string): string;
+/** See the file-level DEVIATION doc comment for why the marker is appended. */
+export declare function buildNodeContent(repo: string, humanId: string, title: string, body: string): string;
+export declare function buildNodeName(repo: string, humanId: string): string;
+/** DESIGN.md §2.2 — importance derived deterministically from priority. */
+export declare function importanceForPriority(priority: Priority | undefined): number;
+export declare function buildTags(kind: string, family: string, userTags?: readonly string[]): string[];
+/** A node counts as a live backlog item iff it carries the tag AND is not superseded (DESIGN.md §14). */
+export declare function isLiveBacklogItemNode(node: NodeRecord): boolean;
+export declare function toBacklogItem(node: NodeRecord): BacklogItem;

package/store/mutate-metadata.d.ts

@@ -0,0 +1,8 @@
+import { BacklogNodeMeta } from './mapping.js';
+import { GraphBacklogStore } from './graph-backlog-store.js';
+
+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;

package/store/query.d.ts

@@ -0,0 +1,28 @@
+import { BacklogNodeMeta } from './mapping.js';
+import { GraphBacklogStore } from './graph-backlog-store.js';
+import { AuditTrailResult, BacklogFilter, BacklogItem, DependencyGraph, StatsScope, TopoOrderResult } from '../model.js';
+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 findItemNode(store: GraphBacklogStore, repo: string, humanId: string): NodeRecord | null;
+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[];
+/**
+ * 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
+ * separate transitions/claims-over-time table) — `history` is therefore
+ * honestly derived from the durable fields we DO keep (a synthetic
+ * `created` entry, every real `note`, every real `citation`), not a
+ * fabricated replay of every status/claim change. Citation entries reuse
+ * `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 type { BacklogNodeMeta };

package/store/structure.d.ts

@@ -0,0 +1,35 @@
+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;
+/**
+ * `@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
+ * reaches past the `GraphBackend` API, confirmed against the real `edge`
+ * table column names (`src`/`dst`/`rel`).
+ */
+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;
+/**
+ * DESIGN.md §14 point 2 (CONFIRMED against the real source): `supersede(oldId,
+ * newContent, meta)` writes `SUPERSEDES` new -> old, sets `is_superseded=1`
+ * on the old node, and mints the new node — ALL in one internal transaction.
+ * It does NOT invalidate the old node (`t_invalid` stays null) — SPEC.md
+ * §5.5 additionally requires the old item to become bi-temporally invalid
+ * with `reason`, so this composes `supersede()` with a status update (BEFORE
+ * 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;
+/** 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[];
+/**
+ * `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;