mdkg 0.1.7 → 0.1.8

package/CHANGELOG.md

@@ -6,6 +6,16 @@ This project follows a pragmatic changelog style inspired by Keep a Changelog. V
 
 mdkg is pre-v1 public alpha software. Command, graph, cache, bundle, and DAL contracts may change quickly while the project converges on a stable v1 surface.
 
+## 0.1.8 - 2026-06-04
+
+### Added
+
+- Added internal local node:sqlite queue foundations for project DB delivery state.
+
+### Changed
+
+- Source release line now targets the next non-published package version after `0.1.7`.
+
 ## 0.1.7 - 2026-06-04
 
 ### Added

package/README.md

@@ -14,7 +14,7 @@ mdkg stays deliberately boring:
 - first-class rebuildable SQLite cache through built-in `node:sqlite`
 - no daemon, hosted index, or vector DB
 
-Current package version in source: `0.1.7`
+Current package version in source: `0.1.8`
 
 mdkg is still pre-v1 public alpha software. The public package is usable, but graph, cache, bundle, and DAL contracts may continue to change quickly while the project converges on a stable v1 surface.
 
@@ -348,9 +348,12 @@ layout is `.mdkg/db/schema`, `.mdkg/db/runtime`, `.mdkg/db/state`, and
 Runtime DB files, WAL, SHM, journal, lock, and temp files are ignored by
 default. `mdkg db init` does not create an active runtime SQLite database.
 Run `mdkg db migrate` after init to create or update the active runtime
-SQLite database at the configured `db.runtime_path`; the first migration writes
-only mdkg-owned generic foundation tables and records migration order,
-checksums, and applied timestamps.
+SQLite database at the configured `db.runtime_path`; built-in migrations write
+mdkg-owned generic foundation tables, then the internal local node:sqlite queue
+foundation, and record migration order, checksums, and applied timestamps.
+Queue state is durable local delivery infrastructure, not canonical event
+history. It is available only through internal helper modules in this release;
+there is no public `mdkg db queue` CLI yet.
 Use `mdkg db verify` for non-mutating health checks over config, layout,
 runtime SQLite integrity, migration metadata, and transient runtime files. Use
 `mdkg db stats` for deterministic table counts, DB size, migration state,

package/dist/cli.js

@@ -222,16 +222,17 @@ function printDbHelp(log, subcommand) {
             log("  mdkg db snapshot diff <left-snapshot> <right-snapshot> [--json]");
             log("\nBoundaries:");
             log("  - `.mdkg/index` is the rebuildable graph cache");
-            log("  - `.mdkg/db` is future project application state");
+            log("  - `.mdkg/db` is project application state");
             log("  - `mdkg db init` creates the generic layout and enables db config");
             log("  - `mdkg db init` does not create an active runtime SQLite database");
             log("  - `mdkg db migrate` creates/updates the active runtime SQLite database");
-            log("  - `mdkg db migrate` applies mdkg-owned generic foundation migrations only");
+            log("  - `mdkg db migrate` applies mdkg-owned foundation and internal queue migrations");
+            log("  - queue tables are internal local delivery state; no public `mdkg db queue` CLI is exposed");
             log("  - `mdkg db verify` checks config, layout, SQLite integrity, migrations, and transient files");
             log("  - `mdkg db stats` reports table counts, migration state, DB size, and receipt counts");
             log("  - `mdkg db snapshot ...` manages opt-in sealed checkpoints and review dumps");
             log("  - active `.mdkg/db/runtime` and transient DB files are ignored by default");
-            log("  - no raw SQL, hosted queue, profile, or publish behavior is exposed here");
+            log("  - no raw SQL, hosted queue, profile, public queue command, or publish behavior is exposed here");
             printGlobalOptions(log);
     }
 }

package/dist/core/project_db_migrations.js

@@ -19,6 +19,40 @@ CREATE TABLE IF NOT EXISTS project_meta (
   value TEXT NOT NULL
 ) STRICT;
 `;
+const QUEUE_MIGRATION_SQL = `
+CREATE TABLE IF NOT EXISTS project_queue_message (
+  queue_name TEXT NOT NULL,
+  message_id TEXT NOT NULL,
+  dedupe_key TEXT,
+  payload_json TEXT NOT NULL,
+  payload_hash TEXT NOT NULL,
+  status TEXT NOT NULL CHECK(status IN ('ready', 'leased', 'acked', 'dead_letter')),
+  available_at_ms INTEGER NOT NULL,
+  attempt_count INTEGER NOT NULL DEFAULT 0 CHECK(attempt_count >= 0),
+  max_attempts INTEGER NOT NULL CHECK(max_attempts > 0),
+  lease_owner TEXT,
+  lease_deadline_ms INTEGER,
+  created_at_ms INTEGER NOT NULL,
+  updated_at_ms INTEGER NOT NULL,
+  last_error TEXT,
+  CHECK (
+    (status = 'leased' AND lease_owner IS NOT NULL AND lease_deadline_ms IS NOT NULL)
+    OR
+    (status <> 'leased' AND lease_owner IS NULL AND lease_deadline_ms IS NULL)
+  ),
+  PRIMARY KEY (queue_name, message_id)
+) STRICT;
+
+CREATE UNIQUE INDEX IF NOT EXISTS project_queue_message_dedupe_unique
+ON project_queue_message(queue_name, dedupe_key)
+WHERE dedupe_key IS NOT NULL;
+
+CREATE INDEX IF NOT EXISTS project_queue_message_ready_idx
+ON project_queue_message(queue_name, status, available_at_ms, created_at_ms, message_id);
+
+CREATE INDEX IF NOT EXISTS project_queue_message_lease_idx
+ON project_queue_message(queue_name, status, lease_deadline_ms, created_at_ms, message_id);
+`;
 const BUILTIN_MIGRATIONS = [
     {
         ordinal: 1,
@@ -26,6 +60,12 @@ const BUILTIN_MIGRATIONS = [
         filename: "001_mdkg_project_db_foundation.sql",
         sql: FOUNDATION_MIGRATION_SQL.trim(),
     },
+    {
+        ordinal: 2,
+        key: "mdkg.project_db.queue.v1",
+        filename: "002_mdkg_project_db_queue.sql",
+        sql: QUEUE_MIGRATION_SQL.trim(),
+    },
 ];
 function loadDatabaseCtor() {
     try {

package/dist/core/project_db_queue.js

@@ -0,0 +1,317 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.enqueueProjectQueueMessage = enqueueProjectQueueMessage;
+exports.claimProjectQueueMessage = claimProjectQueueMessage;
+exports.ackProjectQueueMessage = ackProjectQueueMessage;
+exports.failProjectQueueMessage = failProjectQueueMessage;
+exports.deadLetterProjectQueueMessage = deadLetterProjectQueueMessage;
+exports.releaseExpiredProjectQueueLeases = releaseExpiredProjectQueueLeases;
+exports.readProjectQueueStats = readProjectQueueStats;
+const crypto_1 = __importDefault(require("crypto"));
+function loadDatabaseCtor() {
+    try {
+        const loaded = require("node:sqlite");
+        if (!loaded.DatabaseSync) {
+            throw new Error("node:sqlite DatabaseSync is unavailable");
+        }
+        return loaded.DatabaseSync;
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        throw new Error(`node:sqlite is required for mdkg project DB queues: ${message}`);
+    }
+}
+function nowMs(input) {
+    if (input !== undefined) {
+        assertInteger(input, "now_ms");
+        return input;
+    }
+    return Date.now();
+}
+function assertNonEmpty(value, field) {
+    if (typeof value !== "string" || value.trim() === "") {
+        throw new Error(`${field} must be a non-empty string`);
+    }
+}
+function assertInteger(value, field) {
+    if (!Number.isInteger(value)) {
+        throw new Error(`${field} must be an integer`);
+    }
+}
+function assertPositiveInteger(value, field) {
+    assertInteger(value, field);
+    if (value <= 0) {
+        throw new Error(`${field} must be greater than 0`);
+    }
+}
+function stableJson(value) {
+    if (value === undefined || typeof value === "function" || typeof value === "symbol" || typeof value === "bigint") {
+        throw new Error("payload must be JSON-serializable");
+    }
+    if (value === null || typeof value !== "object") {
+        if (typeof value === "number" && !Number.isFinite(value)) {
+            throw new Error("payload must be JSON-serializable");
+        }
+        const encoded = JSON.stringify(value);
+        if (encoded === undefined) {
+            throw new Error("payload must be JSON-serializable");
+        }
+        return encoded;
+    }
+    if (Array.isArray(value)) {
+        return `[${value.map((item) => stableJson(item)).join(",")}]`;
+    }
+    const object = value;
+    return `{${Object.keys(object)
+        .sort()
+        .map((key) => `${JSON.stringify(key)}:${stableJson(object[key])}`)
+        .join(",")}}`;
+}
+function payloadHash(payloadJson) {
+    return `sha256:${crypto_1.default.createHash("sha256").update(payloadJson).digest("hex")}`;
+}
+function toMessage(row) {
+    return {
+        queue_name: String(row.queue_name),
+        message_id: String(row.message_id),
+        dedupe_key: row.dedupe_key === null || row.dedupe_key === undefined ? null : String(row.dedupe_key),
+        payload_json: String(row.payload_json),
+        payload_hash: String(row.payload_hash),
+        status: String(row.status),
+        available_at_ms: Number(row.available_at_ms),
+        attempt_count: Number(row.attempt_count),
+        max_attempts: Number(row.max_attempts),
+        lease_owner: row.lease_owner === null || row.lease_owner === undefined ? null : String(row.lease_owner),
+        lease_deadline_ms: row.lease_deadline_ms === null || row.lease_deadline_ms === undefined ? null : Number(row.lease_deadline_ms),
+        created_at_ms: Number(row.created_at_ms),
+        updated_at_ms: Number(row.updated_at_ms),
+        last_error: row.last_error === null || row.last_error === undefined ? null : String(row.last_error),
+    };
+}
+function getMessage(db, queueName, messageId) {
+    const row = db
+        .prepare("SELECT * FROM project_queue_message WHERE queue_name = ? AND message_id = ?")
+        .get(queueName, messageId);
+    return row ? toMessage(row) : null;
+}
+function withDb(databasePath, fn) {
+    const DatabaseSync = loadDatabaseCtor();
+    const db = new DatabaseSync(databasePath);
+    try {
+        db.exec("PRAGMA foreign_keys = ON;");
+        return fn(db);
+    }
+    finally {
+        db.close();
+    }
+}
+function withImmediateTransaction(db, fn) {
+    db.exec("BEGIN IMMEDIATE");
+    try {
+        const result = fn();
+        db.exec("COMMIT");
+        return result;
+    }
+    catch (err) {
+        try {
+            db.exec("ROLLBACK");
+        }
+        catch {
+            // ignore rollback failures when no transaction is active
+        }
+        throw err;
+    }
+}
+function enqueueProjectQueueMessage(databasePath, input) {
+    assertNonEmpty(input.queue_name, "queue_name");
+    assertNonEmpty(input.message_id, "message_id");
+    if (input.dedupe_key !== undefined && input.dedupe_key !== null) {
+        assertNonEmpty(input.dedupe_key, "dedupe_key");
+    }
+    const currentNow = nowMs(input.now_ms);
+    const availableAt = input.available_at_ms ?? currentNow;
+    assertInteger(availableAt, "available_at_ms");
+    const maxAttempts = input.max_attempts ?? 3;
+    assertPositiveInteger(maxAttempts, "max_attempts");
+    const payloadJson = stableJson(input.payload);
+    const hash = payloadHash(payloadJson);
+    return withDb(databasePath, (db) => withImmediateTransaction(db, () => {
+        if (input.dedupe_key) {
+            const duplicate = db
+                .prepare("SELECT * FROM project_queue_message WHERE queue_name = ? AND dedupe_key = ?")
+                .get(input.queue_name, input.dedupe_key);
+            if (duplicate) {
+                return { created: false, duplicate: true, message: toMessage(duplicate) };
+            }
+        }
+        db
+            .prepare([
+            "INSERT INTO project_queue_message",
+            "(queue_name, message_id, dedupe_key, payload_json, payload_hash, status, available_at_ms, attempt_count, max_attempts, lease_owner, lease_deadline_ms, created_at_ms, updated_at_ms, last_error)",
+            "VALUES (?, ?, ?, ?, ?, 'ready', ?, 0, ?, NULL, NULL, ?, ?, NULL)",
+        ].join(" "))
+            .run(input.queue_name, input.message_id, input.dedupe_key ?? null, payloadJson, hash, availableAt, maxAttempts, currentNow, currentNow);
+        const message = getMessage(db, input.queue_name, input.message_id);
+        if (!message) {
+            throw new Error("queued message could not be reloaded after insert");
+        }
+        return { created: true, duplicate: false, message };
+    }));
+}
+function claimProjectQueueMessage(databasePath, input) {
+    assertNonEmpty(input.queue_name, "queue_name");
+    assertNonEmpty(input.lease_owner, "lease_owner");
+    assertPositiveInteger(input.lease_ms, "lease_ms");
+    const currentNow = nowMs(input.now_ms);
+    return withDb(databasePath, (db) => withImmediateTransaction(db, () => {
+        const row = db
+            .prepare([
+            "SELECT * FROM project_queue_message",
+            "WHERE queue_name = ?",
+            "AND (",
+            "  (status = 'ready' AND available_at_ms <= ?)",
+            "  OR (status = 'leased' AND lease_deadline_ms <= ?)",
+            ")",
+            "ORDER BY available_at_ms ASC, created_at_ms ASC, message_id ASC",
+            "LIMIT 1",
+        ].join(" "))
+            .get(input.queue_name, currentNow, currentNow);
+        if (!row) {
+            return null;
+        }
+        const message = toMessage(row);
+        db
+            .prepare("UPDATE project_queue_message SET status = 'leased', lease_owner = ?, lease_deadline_ms = ?, updated_at_ms = ? WHERE queue_name = ? AND message_id = ?")
+            .run(input.lease_owner, currentNow + input.lease_ms, currentNow, input.queue_name, message.message_id);
+        return getMessage(db, input.queue_name, message.message_id);
+    }));
+}
+function requireLeasedMessage(db, queueName, messageId, leaseOwner) {
+    const message = getMessage(db, queueName, messageId);
+    if (!message) {
+        throw new Error(`queue message not found: ${queueName}/${messageId}`);
+    }
+    if (message.status !== "leased" || message.lease_owner !== leaseOwner) {
+        throw new Error(`queue message ${messageId} is not leased by ${leaseOwner}`);
+    }
+    return message;
+}
+function ackProjectQueueMessage(databasePath, input) {
+    assertNonEmpty(input.queue_name, "queue_name");
+    assertNonEmpty(input.message_id, "message_id");
+    assertNonEmpty(input.lease_owner, "lease_owner");
+    const currentNow = nowMs(input.now_ms);
+    return withDb(databasePath, (db) => withImmediateTransaction(db, () => {
+        requireLeasedMessage(db, input.queue_name, input.message_id, input.lease_owner);
+        db
+            .prepare("UPDATE project_queue_message SET status = 'acked', lease_owner = NULL, lease_deadline_ms = NULL, updated_at_ms = ? WHERE queue_name = ? AND message_id = ?")
+            .run(currentNow, input.queue_name, input.message_id);
+        const message = getMessage(db, input.queue_name, input.message_id);
+        if (!message) {
+            throw new Error("acked message could not be reloaded");
+        }
+        return message;
+    }));
+}
+function failProjectQueueMessage(databasePath, input) {
+    assertNonEmpty(input.queue_name, "queue_name");
+    assertNonEmpty(input.message_id, "message_id");
+    assertNonEmpty(input.lease_owner, "lease_owner");
+    assertNonEmpty(input.error, "error");
+    const currentNow = nowMs(input.now_ms);
+    const retryAfter = input.retry_after_ms ?? 0;
+    assertInteger(retryAfter, "retry_after_ms");
+    if (retryAfter < 0) {
+        throw new Error("retry_after_ms must be greater than or equal to 0");
+    }
+    return withDb(databasePath, (db) => withImmediateTransaction(db, () => {
+        const message = requireLeasedMessage(db, input.queue_name, input.message_id, input.lease_owner);
+        const attemptCount = message.attempt_count + 1;
+        const status = attemptCount >= message.max_attempts ? "dead_letter" : "ready";
+        const availableAt = status === "ready" ? currentNow + retryAfter : currentNow;
+        db
+            .prepare([
+            "UPDATE project_queue_message",
+            "SET status = ?, attempt_count = ?, available_at_ms = ?, lease_owner = NULL, lease_deadline_ms = NULL, updated_at_ms = ?, last_error = ?",
+            "WHERE queue_name = ? AND message_id = ?",
+        ].join(" "))
+            .run(status, attemptCount, availableAt, currentNow, input.error, input.queue_name, input.message_id);
+        const updated = getMessage(db, input.queue_name, input.message_id);
+        if (!updated) {
+            throw new Error("failed message could not be reloaded");
+        }
+        return updated;
+    }));
+}
+function deadLetterProjectQueueMessage(databasePath, input) {
+    assertNonEmpty(input.queue_name, "queue_name");
+    assertNonEmpty(input.message_id, "message_id");
+    assertNonEmpty(input.lease_owner, "lease_owner");
+    assertNonEmpty(input.error, "error");
+    const currentNow = nowMs(input.now_ms);
+    return withDb(databasePath, (db) => withImmediateTransaction(db, () => {
+        requireLeasedMessage(db, input.queue_name, input.message_id, input.lease_owner);
+        db
+            .prepare("UPDATE project_queue_message SET status = 'dead_letter', lease_owner = NULL, lease_deadline_ms = NULL, updated_at_ms = ?, last_error = ? WHERE queue_name = ? AND message_id = ?")
+            .run(currentNow, input.error, input.queue_name, input.message_id);
+        const message = getMessage(db, input.queue_name, input.message_id);
+        if (!message) {
+            throw new Error("dead-lettered message could not be reloaded");
+        }
+        return message;
+    }));
+}
+function releaseExpiredProjectQueueLeases(databasePath, input = {}) {
+    const currentNow = nowMs(input.now_ms);
+    if (input.queue_name !== undefined) {
+        assertNonEmpty(input.queue_name, "queue_name");
+    }
+    return withDb(databasePath, (db) => withImmediateTransaction(db, () => {
+        const result = input.queue_name
+            ? db
+                .prepare("UPDATE project_queue_message SET status = 'ready', lease_owner = NULL, lease_deadline_ms = NULL, updated_at_ms = ? WHERE queue_name = ? AND status = 'leased' AND lease_deadline_ms <= ?")
+                .run(currentNow, input.queue_name, currentNow)
+            : db
+                .prepare("UPDATE project_queue_message SET status = 'ready', lease_owner = NULL, lease_deadline_ms = NULL, updated_at_ms = ? WHERE status = 'leased' AND lease_deadline_ms <= ?")
+                .run(currentNow, currentNow);
+        return { released_count: Number(result.changes ?? 0) };
+    }));
+}
+function readProjectQueueStats(databasePath, input = {}) {
+    if (input.queue_name !== undefined) {
+        assertNonEmpty(input.queue_name, "queue_name");
+    }
+    const currentNow = nowMs(input.now_ms);
+    return withDb(databasePath, (db) => {
+        const params = input.queue_name ? [input.queue_name] : [];
+        const where = input.queue_name ? "WHERE queue_name = ?" : "";
+        const rows = db
+            .prepare(`SELECT status, COUNT(*) AS count FROM project_queue_message ${where} GROUP BY status`)
+            .all(...params);
+        const byStatus = {
+            ready: 0,
+            leased: 0,
+            acked: 0,
+            dead_letter: 0,
+        };
+        for (const row of rows) {
+            byStatus[String(row.status)] = Number(row.count);
+        }
+        const total = Object.values(byStatus).reduce((sum, count) => sum + count, 0);
+        const readyAvailable = db
+            .prepare(`SELECT COUNT(*) AS count FROM project_queue_message ${where} ${where ? "AND" : "WHERE"} status = 'ready' AND available_at_ms <= ?`)
+            .get(...params, currentNow);
+        const leasedExpired = db
+            .prepare(`SELECT COUNT(*) AS count FROM project_queue_message ${where} ${where ? "AND" : "WHERE"} status = 'leased' AND lease_deadline_ms <= ?`)
+            .get(...params, currentNow);
+        return {
+            total,
+            by_status: byStatus,
+            ready_available: Number(readyAvailable?.count ?? 0),
+            leased_expired: Number(leasedExpired?.count ?? 0),
+        };
+    });
+}

package/dist/init/AGENT_START.md

@@ -34,9 +34,12 @@ Agent operating prompt:
 - Treat `.mdkg/db` as project application state; use `mdkg db init` to create
   the generic scaffold and enable `db.enabled` without creating an active
   runtime SQLite database. Use `mdkg db migrate` after init to create or update
-  the runtime SQLite database with mdkg-owned generic foundation migrations.
-  Use `mdkg db verify` and `mdkg db stats` for non-mutating health and summary
-  receipts. Use `mdkg db snapshot seal` for explicit sealed checkpoints,
+  the runtime SQLite database with mdkg-owned foundation and internal local
+  node:sqlite queue foundation migrations. Queue state is delivery
+  infrastructure, not canonical event history, and there is no public
+  `mdkg db queue` CLI yet. Use `mdkg db verify` and `mdkg db stats` for
+  non-mutating health and summary receipts. Use `mdkg db snapshot seal` for
+  explicit sealed checkpoints,
   `mdkg db snapshot verify/status` for checkpoint health, and
   `mdkg db snapshot dump/diff` for deterministic review aids. Keep
   `.mdkg/db/runtime/` and WAL/SHM/journal/lock/temp files ignored unless a

package/dist/init/CLI_COMMAND_MATRIX.md

@@ -49,9 +49,12 @@ Project database commands:
   `.mdkg/db/project-db.json`, enables `db.enabled`, and does not create an
   active runtime SQLite database
 - `mdkg db migrate` creates or updates the configured active runtime SQLite
-  database and applies mdkg-owned generic foundation migrations only
+  database and applies mdkg-owned foundation plus internal local node:sqlite
+  queue foundation migrations
 - `mdkg db migrate` records migration order, checksums, and applied timestamps
   in the configured migration table
+- queue tables are durable local delivery state, not canonical event history;
+  there is no public `mdkg db queue` CLI yet
 - `mdkg db verify` checks config, layout, runtime SQLite integrity, migration
   metadata, receipt directory policy, and transient runtime files
 - `mdkg db stats` reports table counts, database size, migration state,

package/dist/init/README.md

@@ -75,8 +75,10 @@ Fresh mdkg workspaces default to `index.backend: sqlite`; `.mdkg/index/mdkg.sqli
 `.mdkg/index`. Run `mdkg db init` to create the generic scaffold, write
 `.mdkg/db/project-db.json`, and enable `db.enabled`; it does not create an
 active runtime SQLite database. Run `mdkg db migrate` after init to create or
-update the active runtime SQLite database with mdkg-owned generic foundation
-migrations. Use `mdkg db verify` for non-mutating health checks and
+update the active runtime SQLite database with mdkg-owned foundation and
+internal local node:sqlite queue foundation migrations. Queue state is delivery
+infrastructure, not canonical event history, and there is no public
+`mdkg db queue` CLI yet. Use `mdkg db verify` for non-mutating health checks and
 `mdkg db stats` for table counts, DB size, migration state, and receipt-file
 counts. Use `mdkg db snapshot seal` to create an opt-in sealed checkpoint under
 `.mdkg/db/state`, then use `mdkg db snapshot verify/status` for integrity and

package/dist/init/init-manifest.json

@@ -1,7 +1,7 @@
 {
   "schema_version": 1,
   "tool": "mdkg",
-  "mdkg_version": "0.1.7",
+  "mdkg_version": "0.1.8",
   "files": [
     {
       "path": ".mdkg/config.json",
@@ -61,7 +61,7 @@
     {
       "path": ".mdkg/README.md",
       "category": "mdkg_doc",
-      "sha256": "57a55e0f3743415f5ba1d166d3abf61b2ad868cc11d0e7083b7fd8075dae95a1"
+      "sha256": "6967c433a9a2d63f0fa4680107a318a75af358873f65326678873986a2fe619d"
     },
     {
       "path": ".mdkg/skills/build-pack-and-execute-task/SKILL.md",
@@ -186,7 +186,7 @@
     {
       "path": "AGENT_START.md",
       "category": "startup_doc",
-      "sha256": "d9ba16476749bd96c986f356b40a7abe4b1321b10260f61f85198220c11ac994"
+      "sha256": "e14276e5b8e6e004997cc93eab7dff468322f01fb203e44007594d67bc2ba149"
     },
     {
       "path": "AGENTS.md",
@@ -201,7 +201,7 @@
     {
       "path": "CLI_COMMAND_MATRIX.md",
       "category": "startup_doc",
-      "sha256": "51c8f3e6fff4c2a0c385e39c2c41a0b26136ca9d2efcd4593f0099c3cdc0a4a8"
+      "sha256": "a942886a2ef48eb895ecaae491d8841d11ee446b5879e4fe48fd2a1ac82c8f53"
     },
     {
       "path": "llms.txt",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mdkg",
-  "version": "0.1.7",
+  "version": "0.1.8",
   "description": "Markdown Knowledge Graph",
   "license": "MIT",
   "bin": {
@@ -17,6 +17,7 @@
     "smoke:init": "npm run build && node scripts/smoke-init.js",
     "smoke:capabilities": "npm run build && node scripts/smoke-capabilities.js",
     "smoke:db": "npm run build && node scripts/smoke-db.js",
+    "smoke:db-queue": "npm run build && node scripts/smoke-db-queue.js",
     "smoke:db-snapshot": "npm run build && node scripts/smoke-db-snapshot.js",
     "smoke:archive-work": "npm run build && node scripts/smoke-archive-work.js",
     "smoke:bundle": "npm run build && node scripts/smoke-bundle.js",
@@ -28,7 +29,7 @@
     "cli:snapshot": "npm run build && node scripts/cli_help_snapshot.js",
     "cli:check": "npm run build && node scripts/cli_help_snapshot.js --check",
     "prepack": "npm run build && node scripts/assert-publish-ready.js",
-    "prepublishOnly": "npm run test && npm run cli:check && node dist/cli.js validate && npm run smoke:consumer && npm run smoke:matrix && npm run smoke:upgrade && npm run smoke:init && npm run smoke:capabilities && npm run smoke:db && npm run smoke:db-snapshot && npm run smoke:archive-work && npm run smoke:bundle && npm run smoke:subgraph && npm run smoke:visibility && npm run smoke:sqlite && npm run smoke:parallel && npm run smoke:goal && node scripts/assert-publish-ready.js",
+    "prepublishOnly": "npm run test && npm run cli:check && node dist/cli.js validate && npm run smoke:consumer && npm run smoke:matrix && npm run smoke:upgrade && npm run smoke:init && npm run smoke:capabilities && npm run smoke:db && npm run smoke:db-queue && npm run smoke:db-snapshot && npm run smoke:archive-work && npm run smoke:bundle && npm run smoke:subgraph && npm run smoke:visibility && npm run smoke:sqlite && npm run smoke:parallel && npm run smoke:goal && node scripts/assert-publish-ready.js",
     "postinstall": "node scripts/postinstall.js",
     "smoke:subgraph": "npm run build && node scripts/smoke-subgraph.js"
   },