memorix 1.9.2 → 1.9.4

package/dist/media-video-runner.js

@@ -580,70 +580,79 @@ function getDatabase(dataDir) {
   loadBetterSqlite3();
   fs.mkdirSync(dataDir, { recursive: true });
   const dbPath = path3.join(dataDir, "memorix.db");
-  const db2 = createDatabase(dbPath);
-  db2.pragma("journal_mode = WAL");
-  db2.pragma("busy_timeout = 5000");
-  db2.pragma("foreign_keys = ON");
-  db2.exec(CREATE_OBSERVATIONS_TABLE);
-  db2.exec(CREATE_MINI_SKILLS_TABLE);
-  db2.exec(CREATE_SESSIONS_TABLE);
-  db2.exec(CREATE_META_TABLE);
-  db2.exec(CREATE_TEAM_AGENTS_TABLE);
-  db2.exec(CREATE_TEAM_TASKS_TABLE);
-  db2.exec(CREATE_TEAM_TASK_DEPS_TABLE);
-  db2.exec(CREATE_TEAM_MESSAGES_TABLE);
-  db2.exec(CREATE_TEAM_LOCKS_TABLE);
-  db2.exec(CREATE_TEAM_ROLES_TABLE);
-  db2.exec(CREATE_GRAPH_ENTITIES_TABLE);
-  db2.exec(CREATE_GRAPH_RELATIONS_TABLE);
-  db2.exec(CREATE_CHAT_TRANSCRIPT_TABLE);
-  db2.exec(CREATE_CODE_FILES_TABLE);
-  db2.exec(CREATE_CODE_SYMBOLS_TABLE);
-  db2.exec(CREATE_CODE_EDGES_TABLE);
-  db2.exec(CREATE_OBSERVATION_CODE_REFS_TABLE);
-  db2.exec(CREATE_MAINTENANCE_JOBS_TABLE);
-  db2.exec(CREATE_MAINTENANCE_TARGETS_TABLE);
-  db2.exec(CREATE_COMPACTION_CHECKPOINTS_TABLE);
+  let db2;
   try {
-    db2.exec(`ALTER TABLE mini_skills ADD COLUMN sourceSnapshot TEXT NOT NULL DEFAULT ''`);
-  } catch {
-  }
-  try {
-    db2.exec(`ALTER TABLE mini_skills ADD COLUMN updatedAt TEXT`);
-  } catch {
-  }
-  try {
-    db2.exec(`ALTER TABLE observations ADD COLUMN createdByAgentId TEXT`);
-  } catch {
-  }
-  try {
-    db2.exec(`ALTER TABLE observations ADD COLUMN writeGeneration INTEGER DEFAULT 0`);
-  } catch {
-  }
-  try {
-    db2.exec(`ALTER TABLE team_tasks ADD COLUMN required_role TEXT`);
-  } catch {
-  }
-  try {
-    db2.exec(`ALTER TABLE team_tasks ADD COLUMN preferred_role TEXT`);
-  } catch {
-  }
-  try {
-    db2.exec(`ALTER TABLE team_messages ADD COLUMN to_role TEXT`);
-  } catch {
-  }
-  try {
-    db2.exec(`ALTER TABLE team_messages ADD COLUMN handoff_status TEXT`);
-  } catch {
+    db2 = createDatabase(dbPath);
+    db2.pragma("busy_timeout = 5000");
+    db2.pragma("journal_mode = WAL");
+    db2.pragma("foreign_keys = ON");
+    db2.exec(CREATE_OBSERVATIONS_TABLE);
+    db2.exec(CREATE_MINI_SKILLS_TABLE);
+    db2.exec(CREATE_SESSIONS_TABLE);
+    db2.exec(CREATE_META_TABLE);
+    db2.exec(CREATE_TEAM_AGENTS_TABLE);
+    db2.exec(CREATE_TEAM_TASKS_TABLE);
+    db2.exec(CREATE_TEAM_TASK_DEPS_TABLE);
+    db2.exec(CREATE_TEAM_MESSAGES_TABLE);
+    db2.exec(CREATE_TEAM_LOCKS_TABLE);
+    db2.exec(CREATE_TEAM_ROLES_TABLE);
+    db2.exec(CREATE_GRAPH_ENTITIES_TABLE);
+    db2.exec(CREATE_GRAPH_RELATIONS_TABLE);
+    db2.exec(CREATE_CHAT_TRANSCRIPT_TABLE);
+    db2.exec(CREATE_CODE_FILES_TABLE);
+    db2.exec(CREATE_CODE_SYMBOLS_TABLE);
+    db2.exec(CREATE_CODE_EDGES_TABLE);
+    db2.exec(CREATE_OBSERVATION_CODE_REFS_TABLE);
+    db2.exec(CREATE_MAINTENANCE_JOBS_TABLE);
+    db2.exec(CREATE_MAINTENANCE_TARGETS_TABLE);
+    db2.exec(CREATE_COMPACTION_CHECKPOINTS_TABLE);
+    try {
+      db2.exec(`ALTER TABLE mini_skills ADD COLUMN sourceSnapshot TEXT NOT NULL DEFAULT ''`);
+    } catch {
+    }
+    try {
+      db2.exec(`ALTER TABLE mini_skills ADD COLUMN updatedAt TEXT`);
+    } catch {
+    }
+    try {
+      db2.exec(`ALTER TABLE observations ADD COLUMN createdByAgentId TEXT`);
+    } catch {
+    }
+    try {
+      db2.exec(`ALTER TABLE observations ADD COLUMN writeGeneration INTEGER DEFAULT 0`);
+    } catch {
+    }
+    try {
+      db2.exec(`ALTER TABLE team_tasks ADD COLUMN required_role TEXT`);
+    } catch {
+    }
+    try {
+      db2.exec(`ALTER TABLE team_tasks ADD COLUMN preferred_role TEXT`);
+    } catch {
+    }
+    try {
+      db2.exec(`ALTER TABLE team_messages ADD COLUMN to_role TEXT`);
+    } catch {
+    }
+    try {
+      db2.exec(`ALTER TABLE team_messages ADD COLUMN handoff_status TEXT`);
+    } catch {
+    }
+    applySchemaMigrations(db2);
+    db2.exec(CREATE_INDEXES);
+    initializeObservationLexicalIndex(db2);
+    db2.prepare(`INSERT OR IGNORE INTO meta (key, value) VALUES ('storage_generation', '0')`).run();
+    db2.prepare(`INSERT OR IGNORE INTO meta (key, value) VALUES ('next_id', '1')`).run();
+    db2.prepare(`INSERT OR IGNORE INTO meta (key, value) VALUES ('mini_skills_generation', '0')`).run();
+    _dbCache.set(normalized, db2);
+    return db2;
+  } catch (error) {
+    try {
+      db2?.close();
+    } catch {
+    }
+    throw error;
   }
-  applySchemaMigrations(db2);
-  db2.exec(CREATE_INDEXES);
-  initializeObservationLexicalIndex(db2);
-  db2.prepare(`INSERT OR IGNORE INTO meta (key, value) VALUES ('storage_generation', '0')`).run();
-  db2.prepare(`INSERT OR IGNORE INTO meta (key, value) VALUES ('next_id', '1')`).run();
-  db2.prepare(`INSERT OR IGNORE INTO meta (key, value) VALUES ('mini_skills_generation', '0')`).run();
-  _dbCache.set(normalized, db2);
-  return db2;
 }
 function closeAllDatabases() {
   for (const [key, db2] of _dbCache) {
@@ -1633,6 +1642,74 @@ CREATE UNIQUE INDEX IF NOT EXISTS idx_maintenance_jobs_active_dedupe
   }
 });
 
+// src/store/sqlite-reliability.ts
+function isTransientSqliteError(error) {
+  const code = error?.code;
+  if (typeof code === "string") {
+    return /^SQLITE_BUSY(?:_|$)/i.test(code);
+  }
+  return error instanceof Error && /\bdatabase is locked\b|\bdatabase is busy\b/i.test(error.message);
+}
+function isSqliteUnavailableError(error) {
+  return error instanceof SqliteUnavailableError || error instanceof Error && /SQLite is not available|better-sqlite3.*failed|node:sqlite.*failed|bun:sqlite.*failed/i.test(error.message);
+}
+function degradedReadError(storeName) {
+  return new Error(`[memorix] Cannot read ${storeName}: SQLite backend unavailable (memory is not loaded)`);
+}
+function degradedWriteError(storeName) {
+  return new Error(`[memorix] Cannot write ${storeName}: SQLite backend unavailable (degraded mode; read-only)`);
+}
+function formatSqliteFailure(error) {
+  return error instanceof Error && error.message ? error.message : String(error);
+}
+function delay(ms) {
+  return new Promise((resolve2) => setTimeout(resolve2, ms));
+}
+async function retrySqliteBusy(operation, label) {
+  for (let attempt = 0; ; attempt++) {
+    try {
+      return await operation();
+    } catch (error) {
+      if (!isTransientSqliteError(error) || attempt >= SQLITE_BUSY_RETRY_DELAYS_MS.length) throw error;
+      const waitMs = SQLITE_BUSY_RETRY_DELAYS_MS[attempt];
+      console.error(
+        `[memorix] ${label} SQLite busy (attempt ${attempt + 1}/${SQLITE_BUSY_RETRY_DELAYS_MS.length + 1}), retrying in ${waitMs}ms`
+      );
+      await delay(waitMs);
+    }
+  }
+}
+async function initializeSqliteStore(factory, dataDir, label) {
+  try {
+    loadBetterSqlite3();
+  } catch (error) {
+    throw new SqliteUnavailableError(error);
+  }
+  return retrySqliteBusy(async () => {
+    const store = factory();
+    await store.init(dataDir);
+    return store;
+  }, label);
+}
+var SQLITE_BUSY_RETRY_DELAYS_MS, SqliteUnavailableError;
+var init_sqlite_reliability = __esm({
+  "src/store/sqlite-reliability.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_sqlite_db();
+    SQLITE_BUSY_RETRY_DELAYS_MS = [50, 150, 400, 1e3, 2500];
+    SqliteUnavailableError = class extends Error {
+      code = "MEMORIX_SQLITE_UNAVAILABLE";
+      constructor(cause) {
+        super(
+          cause instanceof Error && cause.message ? cause.message : "[memorix] SQLite is unavailable (install a supported SQLite runtime)"
+        );
+        this.name = "SqliteUnavailableError";
+      }
+    };
+  }
+});
+
 // src/store/file-lock.ts
 import { promises as fs2 } from "fs";
 import { randomUUID } from "crypto";
@@ -3556,10 +3633,10 @@ async function fetchWithRetry(url, apiKey, body, options = {}, attempt = 0, nati
       );
     }
     if (options.retry !== false && (response.status === 429 || response.status >= 500) && attempt < MAX_RETRIES2) {
-      const delay2 = BASE_DELAY_MS * Math.pow(2, attempt);
+      const delay3 = BASE_DELAY_MS * Math.pow(2, attempt);
       const retryAfter = response.headers.get("retry-after");
       const parsedRetryAfter = retryAfter ? parseInt(retryAfter, 10) * 1e3 : NaN;
-      const waitMs = Number.isFinite(parsedRetryAfter) ? parsedRetryAfter : delay2;
+      const waitMs = Number.isFinite(parsedRetryAfter) ? parsedRetryAfter : delay3;
       console.error(`[memorix] Embedding API ${response.status}, retry ${attempt + 1}/${MAX_RETRIES2} in ${waitMs}ms`);
       await waitForRetry(waitMs, options.signal);
       return fetchWithRetry(url, apiKey, body, options, attempt + 1, nativeGemini);
@@ -5591,6 +5668,7 @@ var init_sqlite_store = __esm({
     "use strict";
     init_esm_shims();
     init_sqlite_db();
+    init_sqlite_reliability();
     init_sqlite_fts();
     SqliteBackend = class {
       db = null;
@@ -5868,7 +5946,9 @@ var init_sqlite_store = __esm({
       // ── Compound atomic operation ────────────────────────────────────
       async atomic(fn) {
         const run = this._atomicQueue.catch(() => void 0).then(async () => {
-          this.db.prepare("BEGIN IMMEDIATE").run();
+          await retrySqliteBusy(async () => {
+            this.db.prepare("BEGIN IMMEDIATE").run();
+          }, "Observation atomic write");
           try {
             const tx = {
               loadAll: async () => this.rawLoadAll(),
@@ -5967,15 +6047,15 @@ function resetObservationStore() {
 async function createObservationStore(dataDir) {
   try {
     const { SqliteBackend: SqliteBackend2 } = await Promise.resolve().then(() => (init_sqlite_store(), sqlite_store_exports));
-    const store2 = new SqliteBackend2();
-    await store2.init(dataDir);
-    return store2;
+    return await initializeSqliteStore(() => new SqliteBackend2(), dataDir, "Observation store");
   } catch (err) {
-    console.error(`[memorix] SQLite backend unavailable \u2014 degraded mode (read-only): ${err instanceof Error ? err.message : err}`);
+    if (!isSqliteUnavailableError(err)) throw err;
+    const reason = formatSqliteFailure(err);
+    console.error(`[memorix] SQLite module unavailable \u2014 degraded mode (reads/writes disabled): ${reason}`);
+    const degraded = new DegradedBackend(reason);
+    await degraded.init(dataDir);
+    return degraded;
   }
-  const store = new DegradedBackend();
-  await store.init(dataDir);
-  return store;
 }
 async function initObservationStore(dataDir) {
   if (_store2 && _storeDataDir === dataDir) {
@@ -5999,36 +6079,44 @@ var init_obs_store = __esm({
   "src/store/obs-store.ts"() {
     "use strict";
     init_esm_shims();
+    init_sqlite_reliability();
     _store2 = null;
     _storeDataDir = null;
     DegradedBackend = class {
+      constructor(reason = "SQLite runtime unavailable") {
+        this.reason = reason;
+      }
+      reason;
       dataDir = "";
+      unavailableRead() {
+        return degradedReadError("observations");
+      }
       async init(dataDir) {
         this.dataDir = dataDir;
       }
       async loadAll() {
-        return [];
+        throw this.unavailableRead();
       }
       async loadByProject(_projectId, _options) {
-        return [];
+        throw this.unavailableRead();
       }
       async countByProject(_projectId, _options) {
-        return 0;
+        throw this.unavailableRead();
       }
       async getById(_id) {
-        return void 0;
+        throw this.unavailableRead();
       }
       async loadIdCounter() {
-        return 1;
+        throw this.unavailableRead();
       }
       async countAll() {
-        return 0;
+        throw this.unavailableRead();
       }
       async listProjectIds() {
-        return [];
+        throw this.unavailableRead();
       }
       async searchLexical(_options) {
-        return [];
+        throw this.unavailableRead();
       }
       hasLexicalIndex() {
         return false;
@@ -6037,25 +6125,25 @@ var init_obs_store = __esm({
         return false;
       }
       async insert(_obs) {
-        throw new Error("[memorix] Cannot write observations: SQLite backend unavailable (degraded mode)");
+        throw degradedWriteError("observations");
       }
       async update(_obs) {
-        throw new Error("[memorix] Cannot write observations: SQLite backend unavailable (degraded mode)");
+        throw degradedWriteError("observations");
       }
       async remove(_id) {
-        throw new Error("[memorix] Cannot write observations: SQLite backend unavailable (degraded mode)");
+        throw degradedWriteError("observations");
       }
       async bulkReplace(_obs) {
-        throw new Error("[memorix] Cannot write observations: SQLite backend unavailable (degraded mode)");
+        throw degradedWriteError("observations");
       }
       async bulkRemoveByIds(_ids) {
-        throw new Error("[memorix] Cannot write observations: SQLite backend unavailable (degraded mode)");
+        throw degradedWriteError("observations");
       }
       async saveIdCounter(_nextId) {
-        throw new Error("[memorix] Cannot write observations: SQLite backend unavailable (degraded mode)");
+        throw degradedWriteError("observations");
       }
       async atomic(_fn) {
-        throw new Error("[memorix] Cannot write observations: SQLite backend unavailable (degraded mode)");
+        throw degradedWriteError("observations");
       }
       async ensureFresh() {
         return false;
@@ -6068,6 +6156,9 @@ var init_obs_store = __esm({
       getBackendName() {
         return "degraded";
       }
+      getBackendReason() {
+        return this.reason;
+      }
     };
   }
 });
@@ -55275,10 +55366,10 @@ var require_retry3 = __commonJS({
       if (!await shouldRetryFn(err)) {
         return { shouldRetry: false, config: err.config };
       }
-      const delay2 = getNextRetryDelay(config);
+      const delay3 = getNextRetryDelay(config);
       err.config.retryConfig.currentRetryAttempt += 1;
-      const backoff = config.retryBackoff ? config.retryBackoff(err, delay2) : new Promise((resolve2) => {
-        setTimeout(resolve2, delay2);
+      const backoff = config.retryBackoff ? config.retryBackoff(err, delay3) : new Promise((resolve2) => {
+        setTimeout(resolve2, delay3);
       });
       if (config.onRetryAttempt) {
         await config.onRetryAttempt(err);
@@ -97064,7 +97155,7 @@ async function retryBackoff(fn, strategy) {
         retryInterval = initialInterval * Math.pow(x2, exponent) + Math.random() * 1e3;
       }
       const d = Math.min(retryInterval, maxInterval);
-      await delay(d);
+      await delay2(d);
       x2++;
     }
   }
@@ -97085,8 +97176,8 @@ function retryIntervalFromResponse(res) {
   }
   return 0;
 }
-async function delay(delay2) {
-  return new Promise((resolve2) => setTimeout(resolve2, delay2));
+async function delay2(delay3) {
+  return new Promise((resolve2) => setTimeout(resolve2, delay3));
 }
 var defaultBackoff, PermanentError, TemporaryError, codeRangeRE2;
 var init_retries = __esm({
@@ -143363,7 +143454,20 @@ function normalizeMiniMaxVideoRequest(input) {
   if (ratio !== "adaptive" && ratio !== "16:9" && ratio !== "9:16" && ratio !== "1:1") {
     throw new Error("MiniMax video ratio must be adaptive, 16:9, 9:16, or 1:1");
   }
-  return { region, model, prompt, resolution, duration, ratio };
+  let firstFrameImageUrl;
+  if (input.firstFrameImageUrl !== void 0) {
+    firstFrameImageUrl = input.firstFrameImageUrl.trim();
+    let parsed;
+    try {
+      parsed = new URL(firstFrameImageUrl);
+    } catch {
+      throw new Error("MiniMax first-frame image must be a public HTTPS URL");
+    }
+    if (parsed.protocol !== "https:" || parsed.username || parsed.password || sanitizeCredentials(firstFrameImageUrl) !== firstFrameImageUrl) {
+      throw new Error("MiniMax first-frame image must be an HTTPS URL without credentials");
+    }
+  }
+  return { region, model, prompt, resolution, duration, ratio, ...firstFrameImageUrl ? { firstFrameImageUrl } : {} };
 }
 function videoRequestConfig(input) {
   const normalized = normalizeMiniMaxVideoRequest(input);
@@ -143440,7 +143544,14 @@ async function createMiniMaxVideoTask(input, dependencies = {}) {
       headers: videoHeaders(config.apiKey),
       body: JSON.stringify({
         model: config.model,
-        content: [{ type: "text", text: config.prompt }],
+        content: [
+          { type: "text", text: config.prompt },
+          ...config.firstFrameImageUrl ? [{
+            type: "image_url",
+            image_url: { url: config.firstFrameImageUrl },
+            role: "first_frame"
+          }] : []
+        ],
         resolution: config.resolution,
         duration: config.duration,
         ratio: config.ratio
@@ -143601,10 +143712,19 @@ function parseStoredRequest(value) {
   const duration = value.duration;
   const ratio = value.ratio;
   const maxBytes = value.maxBytes;
-  if (provider2 !== "minimax" && provider2 !== "minimax-cn" || region !== "global" && region !== "cn" || model !== "MiniMax-H3" || typeof prompt !== "string" || resolution !== "2K" || duration !== 5 && duration !== 10 || ratio !== "adaptive" && ratio !== "16:9" && ratio !== "9:16" && ratio !== "1:1" || typeof maxBytes !== "number" || !Number.isSafeInteger(maxBytes) || maxBytes < 1) {
+  if (provider2 !== "minimax" && provider2 !== "minimax-cn" || region !== "global" && region !== "cn" || model !== "MiniMax-H3" || typeof prompt !== "string" || value.firstFrameImageUrl !== void 0 && typeof value.firstFrameImageUrl !== "string" || resolution !== "2K" || duration !== 5 && duration !== 10 || ratio !== "adaptive" && ratio !== "16:9" && ratio !== "9:16" && ratio !== "1:1" || typeof maxBytes !== "number" || !Number.isSafeInteger(maxBytes) || maxBytes < 1) {
     throw new Error("Media video job has an invalid request payload");
   }
-  return { provider: provider2, region, model, prompt, resolution, duration, ratio, maxBytes };
+  const normalized = normalizeMiniMaxVideoRequest({
+    region,
+    model,
+    prompt,
+    resolution,
+    duration,
+    ratio,
+    firstFrameImageUrl: value.firstFrameImageUrl
+  });
+  return { provider: provider2, ...normalized, maxBytes };
 }
 function mediaJobIdFromMaintenance(job) {
   const mediaJobId = job.payload.mediaJobId;
@@ -143616,6 +143736,7 @@ function mediaJobIdFromMaintenance(job) {
 function toVideoRequest(request) {
   return {
     prompt: request.prompt,
+    firstFrameImageUrl: request.firstFrameImageUrl,
     model: request.model,
     region: request.region,
     resolution: request.resolution,
@@ -143707,6 +143828,7 @@ function queueMiniMaxVideoGeneration(input) {
     region: normalized.region,
     model: normalized.model,
     prompt: normalized.prompt,
+    ...normalized.firstFrameImageUrl ? { firstFrameImageUrl: normalized.firstFrameImageUrl } : {},
     resolution: normalized.resolution,
     duration: normalized.duration,
     ratio: normalized.ratio,

package/dist/memcode-runtime/CHANGELOG.md

@@ -4,6 +4,33 @@ All notable changes to this project will be documented in this file.
 
 ## [Unreleased]
 
+## [1.9.4] - 2026-09-18
+
+### Added
+- **MiniMax first-frame video input** -- image-to-video generation now accepts
+  a public HTTPS first-frame image URL through the CLI and MCP surfaces,
+  preserves it in durable media jobs, and submits it with the provider's
+  `first_frame` image role.
+
+### Fixed
+- **First-frame URL safety** -- rejects non-HTTPS URLs and embedded credentials
+  before a media request is submitted or persisted.
+
+### Changed
+- **Grok Build documentation** -- the README comparison now uses the official
+  Grok Build logo assets.
+
+## [1.9.3] - 2026-09-14
+
+### Fixed
+- **SQLite storage reliability** -- transient cross-process locks no longer
+  turn a process into a permanently empty read-only store. Observations,
+  sessions, and mini-skills share the same initialization and retry contract;
+  persistent runtime failures remain visible.
+- **Storage diagnostics** -- `memorix doctor` reports the active backend,
+  distinguishes unavailable storage from an empty project, and returns a
+  failing exit status for storage failures.
+
 ## [1.9.2] - 2026-09-11
 
 ### Fixed