memorix 1.9.2 → 1.9.4

package/plugins/gemini/memorix/gemini-extension.json

@@ -1,6 +1,6 @@
 {
   "name": "memorix",
-  "version": "1.9.2",
+  "version": "1.9.4",
   "mcpServers": {
     "memorix": {
       "command": "memorix",

package/plugins/hermes/memorix/plugin.yaml

@@ -1,5 +1,5 @@
 name: memorix
-version: "1.9.2"
+version: "1.9.4"
 description: Shared workspace memory bridge for Hermes Agent.
 author: AVIDS2
 license: Apache-2.0

package/plugins/omp/memorix/package.json

@@ -1,6 +1,6 @@
 {
   "name": "memorix-omp-package",
-  "version": "1.9.2",
+  "version": "1.9.4",
   "description": "Memorix shared workspace memory package for Oh-my-Pi.",
   "license": "Apache-2.0",
   "keywords": [

package/plugins/openclaw/memorix/.codex-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "memorix",
-  "version": "1.9.2",
+  "version": "1.9.4",
   "description": "Shared workspace memory for OpenClaw and other AI coding agents.",
   "author": {
     "name": "AVIDS2",

package/plugins/pi/memorix/package.json

@@ -1,6 +1,6 @@
 {
   "name": "memorix-pi-package",
-  "version": "1.9.2",
+  "version": "1.9.4",
   "description": "Memorix shared workspace memory package for Pi coding agent.",
   "license": "Apache-2.0",
   "keywords": [

package/server.json

@@ -7,7 +7,7 @@
     "url": "https://github.com/AVIDS2/memorix",
     "source": "github"
   },
-  "version": "1.9.2",
+  "version": "1.9.4",
   "websiteUrl": "https://mem.rglens.com",
   "icons": [
     {
@@ -22,7 +22,7 @@
     {
       "registryType": "npm",
       "identifier": "memorix",
-      "version": "1.9.2",
+      "version": "1.9.4",
       "runtimeHint": "npx",
       "packageArguments": [
         {

package/src/cli/commands/doctor.ts

@@ -283,11 +283,14 @@ export default defineCommand({
       let activeCount = 0;
       let ranCount = 0;
       let backendName = 'unknown';
+      let backendReason: string | undefined;
+      let observationFailure: string | undefined;
       try {
         const { initObservationStore, getObservationStore } = await import('../../store/obs-store.js');
         await initObservationStore(dataDir);
         const store = getObservationStore();
         backendName = store.getBackendName();
+        backendReason = store.getBackendReason?.();
         const { filterReadableObservations } = await import('../../memory/visibility.js');
         projectObservations = projectId
           ? filterReadableObservations(await store.loadAll(), { projectId })
@@ -295,12 +298,30 @@ export default defineCommand({
         obsCount = projectObservations.length;
         activeCount = projectObservations.filter((o: any) => (o.status ?? 'active') === 'active').length;
         ranCount = projectObservations.filter((o: any) => /^Ran:\s/i.test(o.title ?? '')).length;
-      } catch { /* ignore */ }
+      } catch (error) {
+        // The store could not be opened at all. Without this the counters stay
+        // at zero and the branch below reports "0 total" as a healthy result,
+        // which is indistinguishable from a project that has no observations.
+        observationFailure = error instanceof Error ? error.message : String(error);
+      }
 
-      if (backendName === 'degraded') {
-        lines.push(warn('Observations: SQLite unavailable — degraded (read-only, no data)'));
-        issues.push('SQLite backend unavailable — observations cannot be read or written.');
+      if (observationFailure) {
+        lines.push(fail(`Observations: storage unavailable — ${observationFailure}`));
+        issues.push(`Observation store could not be opened: ${observationFailure}`);
+        (report.data as any) = {
+          backend: 'unavailable',
+          observations: null,
+          active: null,
+          commandLogs: null,
+          error: observationFailure,
+        };
+      } else if (backendName === 'degraded') {
+        lines.push(fail(`Backend: degraded (read-only; writes disabled${backendReason ? `; ${backendReason}` : ''})`));
+        lines.push(fail('Observations: unavailable — count not reported'));
+        issues.push('SQLite backend unavailable — observation storage is in degraded read-only mode; observations are not being persisted.');
+        (report.data as any) = { backend: 'degraded', ...(backendReason ? { backendReason } : {}), observations: null, active: null, commandLogs: null };
       } else {
+        lines.push(ok('Backend: sqlite (read-write)'));
         lines.push(ok(`Observations: ${obsCount} total, ${activeCount} active`));
         if (ranCount > 0) {
           const pct = Math.round(ranCount / obsCount * 100);
@@ -310,32 +331,68 @@ export default defineCommand({
           }
         }
       }
-      report.data = { observations: obsCount, active: activeCount, commandLogs: ranCount };
+      if (!report.data) {
+        report.data = { backend: backendName, observations: obsCount, active: activeCount, commandLogs: ranCount };
+      } else if (!(report.data as any).backend) {
+        (report.data as any).backend = backendName;
+      }
 
       // Sessions — read from SQLite (canonical store)
+      let sessionBackend = 'unknown';
+      let sessionReason: string | undefined;
       try {
         const { initSessionStore, getSessionStore } = await import('../../store/session-store.js');
         await initSessionStore(dataDir);
         const sessStore = getSessionStore();
-        const sess = await sessStore.loadAll();
-        const sessCount = sess.length;
-        const activeSess = sess.filter((s: any) => s.status === 'active').length;
-        lines.push(ok(`Sessions: ${sessCount} total, ${activeSess} active`));
-        (report.data as any).sessions = sessCount;
-      } catch { /* ignore */ }
+        sessionBackend = sessStore.getBackendName();
+        sessionReason = sessStore.getBackendReason?.();
+        if (sessionBackend === 'degraded') {
+          lines.push(fail(`Sessions: unavailable — read-only degraded backend${sessionReason ? `; ${sessionReason}` : ''}`));
+          issues.push('Session storage is in degraded read-only mode.');
+          (report.data as any).sessions = null;
+          if (sessionReason) (report.data as any).sessionBackendReason = sessionReason;
+        } else {
+          const sess = await sessStore.loadAll();
+          const sessCount = sess.length;
+          const activeSess = sess.filter((s: any) => s.status === 'active').length;
+          lines.push(ok(`Sessions: ${sessCount} total, ${activeSess} active`));
+          (report.data as any).sessions = sessCount;
+        }
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        lines.push(fail(`Sessions: unavailable (${message})`));
+        issues.push(`Session storage is unavailable: ${message}`);
+        (report.data as any).sessions = null;
+      }
 
       // Mini-skills — read from SQLite (canonical store)
+      let skillBackend = 'unknown';
+      let skillReason: string | undefined;
       try {
         const { initMiniSkillStore, getMiniSkillStore } = await import('../../store/mini-skill-store.js');
         await initMiniSkillStore(dataDir);
         const skillStore = getMiniSkillStore();
-        const skills = await skillStore.loadAll();
-        const skillCount = skills.length;
-        if (skillCount > 0) {
-          lines.push(ok(`Mini-skills: ${skillCount}`));
-          (report.data as any).miniSkills = skillCount;
+        skillBackend = skillStore.getBackendName();
+        skillReason = skillStore.getBackendReason?.();
+        if (skillBackend === 'degraded') {
+          lines.push(fail(`Mini-skills: unavailable — read-only degraded backend${skillReason ? `; ${skillReason}` : ''}`));
+          issues.push('Mini-skill storage is in degraded read-only mode.');
+          (report.data as any).miniSkills = null;
+          if (skillReason) (report.data as any).miniSkillBackendReason = skillReason;
+        } else {
+          const skills = await skillStore.loadAll();
+          const skillCount = skills.length;
+          if (skillCount > 0) {
+            lines.push(ok(`Mini-skills: ${skillCount}`));
+            (report.data as any).miniSkills = skillCount;
+          }
         }
-      } catch { /* ignore */ }
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        lines.push(fail(`Mini-skills: unavailable (${message})`));
+        issues.push(`Mini-skill storage is unavailable: ${message}`);
+        (report.data as any).miniSkills = null;
+      }
     } else {
       lines.push(warn('No data directory found for current project'));
       if (!projectId) {
@@ -633,5 +690,9 @@ export default defineCommand({
     } else {
       console.log(lines.join('\n'));
     }
+
+    if (issues.some((issue) => /^(Observation store could not be opened|Observation storage |Session storage |Mini-skill storage |SQLite backend unavailable)/.test(issue))) {
+      process.exitCode = 1;
+    }
   },
 });

package/src/cli/commands/media.ts

@@ -146,6 +146,7 @@ export default defineCommand({
     concepts: { type: 'string', description: 'Comma-separated concepts when attaching' },
     visibility: { type: 'string', description: 'Observation visibility when attaching' },
     prompt: { type: 'string', description: 'Generation prompt' },
+    'first-frame-image-url': { type: 'string', description: 'Public HTTPS first-frame image URL for MiniMax video generation; stored with the queued job' },
     image: { type: 'string', description: 'Path to a reference image for image-to-image generation' },
     model: { type: 'string', description: 'Provider model' },
     provider: { type: 'string', description: 'Audio transcription provider: openai or groq' },
@@ -201,6 +202,7 @@ export default defineCommand({
               dataDir,
               projectId: project.id,
               prompt,
+              firstFrameImageUrl: args['first-frame-image-url'] as string | undefined,
               model: parseMiniMaxVideoModel(args.model),
               region: parseMiniMaxRegion(args.region),
               duration: parseMiniMaxVideoDuration(args.duration),

package/src/media/minimax.ts

@@ -47,6 +47,7 @@ export interface GeneratedMiniMaxImages {
 
 export interface MiniMaxVideoGenerationRequest {
   prompt: string;
+  firstFrameImageUrl?: string;
   model?: MiniMaxVideoModel;
   region?: MiniMaxRegion;
   apiKey?: string;
@@ -162,6 +163,7 @@ export function normalizeMiniMaxVideoRequest(input: MiniMaxVideoGenerationReques
   region: MiniMaxRegion;
   model: MiniMaxVideoModel;
   prompt: string;
+  firstFrameImageUrl?: string;
   resolution: MiniMaxVideoResolution;
   duration: 5 | 10;
   ratio: MiniMaxVideoRatio;
@@ -178,7 +180,21 @@ export function normalizeMiniMaxVideoRequest(input: MiniMaxVideoGenerationReques
   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: string | undefined;
+  if (input.firstFrameImageUrl !== undefined) {
+    firstFrameImageUrl = input.firstFrameImageUrl.trim();
+    let parsed: URL;
+    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: MiniMaxVideoGenerationRequest): {
@@ -187,6 +203,7 @@ function videoRequestConfig(input: MiniMaxVideoGenerationRequest): {
   baseUrl: string;
   model: MiniMaxVideoModel;
   prompt: string;
+  firstFrameImageUrl?: string;
   resolution: MiniMaxVideoResolution;
   duration: 5 | 10;
   ratio: MiniMaxVideoRatio;
@@ -284,7 +301,14 @@ export async function createMiniMaxVideoTask(
       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,

package/src/media/video-jobs.ts

@@ -32,6 +32,7 @@ interface StoredMiniMaxVideoRequest {
   region: 'global' | 'cn';
   model: 'MiniMax-H3';
   prompt: string;
+  firstFrameImageUrl?: string;
   resolution: '2K';
   duration: 5 | 10;
   ratio: 'adaptive' | '16:9' | '9:16' | '1:1';
@@ -93,13 +94,18 @@ function parseStoredRequest(value: Record<string, unknown>): StoredMiniMaxVideoR
     || (region !== 'global' && region !== 'cn')
     || model !== 'MiniMax-H3'
     || typeof prompt !== 'string'
+    || (value.firstFrameImageUrl !== undefined && 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, region, model, prompt, resolution, duration, ratio, maxBytes };
+  const normalized = normalizeMiniMaxVideoRequest({
+    region, model, prompt, resolution, duration, ratio,
+    firstFrameImageUrl: value.firstFrameImageUrl as string | undefined,
+  });
+  return { provider, ...normalized, maxBytes };
 }
 
 function mediaJobIdFromMaintenance(job: MaintenanceJob): string {
@@ -113,6 +119,7 @@ function mediaJobIdFromMaintenance(job: MaintenanceJob): string {
 function toVideoRequest(request: StoredMiniMaxVideoRequest): MiniMaxVideoGenerationRequest {
   return {
     prompt: request.prompt,
+    firstFrameImageUrl: request.firstFrameImageUrl,
     model: request.model,
     region: request.region,
     resolution: request.resolution,
@@ -233,6 +240,7 @@ export function queueMiniMaxVideoGeneration(input: QueueMiniMaxVideoInput): Queu
     region: normalized.region,
     model: normalized.model,
     prompt: normalized.prompt,
+    ...(normalized.firstFrameImageUrl ? { firstFrameImageUrl: normalized.firstFrameImageUrl } : {}),
     resolution: normalized.resolution,
     duration: normalized.duration,
     ratio: normalized.ratio,

package/src/server.ts

@@ -5208,6 +5208,7 @@ export async function createMemorixServer(
         } : {}),
         ...(mediaGenerationEnabled ? {
           image: z.string().optional().describe('Base64-encoded reference image for image-to-image generation.'),
+          firstFrameImageUrl: z.string().optional().describe('Public HTTPS first-frame image URL for MiniMax video generation; stored with the queued job.'),
           region: z.enum(['global', 'cn']).optional().describe('MiniMax deployment region.'),
           n: z.number().int().min(1).max(4).optional().describe('Image output count.'),
           ratio: z.enum(['adaptive', '1:1', '16:9', '4:3', '3:2', '2:3', '3:4', '9:16', '21:9']).optional().describe('Image or video aspect ratio.'),
@@ -5217,7 +5218,7 @@ export async function createMemorixServer(
         } : {}),
       },
     },
-    async ({ action, path: assetPath, assetId, jobId, kind, limit, title, narrative, prompt, image, model, provider, language, region, n, ratio, width, height, duration, maxPages, maxChars, attach }) => {
+    async ({ action, path: assetPath, assetId, jobId, kind, limit, title, narrative, prompt, image, firstFrameImageUrl, model, provider, language, region, n, ratio, width, height, duration, maxPages, maxChars, attach }) => {
       const unresolved = requireResolvedProject('manage controlled media');
       if (unresolved) return unresolved;
       const safeError = (error: unknown) => sanitizeCredentials(
@@ -5402,6 +5403,7 @@ export async function createMemorixServer(
             dataDir: projectDir,
             projectId: project.id,
             prompt,
+            firstFrameImageUrl,
             ...(model === 'MiniMax-H3' ? { model } : {}),
             ...(region ? { region } : {}),
             ...(videoRatio ? { ratio: videoRatio } : {}),

package/src/store/mini-skill-store.ts

@@ -3,7 +3,7 @@
  *
  * Backends:
  *   - MiniSkillSqliteStore — canonical store, uses shared DB handle from sqlite-db.ts
- *   - MiniSkillGracefulDegrade — no-op fallback when SQLite is unavailable
+ *   - MiniSkillGracefulDegrade — explicit read-only fallback when SQLite is unavailable
  *
  * Phase 2 debt-zero: SQLite is the only canonical store for mini-skills.
  * JSON files are migration source only. No writable JSON fallback exists.
@@ -11,6 +11,7 @@
 
 import type { MiniSkill } from '../types.js';
 import { getDatabase } from './sqlite-db.js';
+import { degradedReadError, degradedWriteError, initializeSqliteStore, isSqliteUnavailableError, retrySqliteBusy } from './sqlite-reliability.js';
 import {
   loadMiniSkillsJson,
 } from './persistence.js';
@@ -36,6 +37,7 @@ export interface MiniSkillStore {
   ensureFresh(): Promise<boolean>;
   getGeneration(): number;
   getBackendName(): 'sqlite' | 'degraded';
+  getBackendReason?(): string | undefined;
 }
 
 // ── Row <-> MiniSkill serialization ─────────────────────────────────
@@ -220,7 +222,7 @@ export class MiniSkillSqliteStore implements MiniSkillStore {
    * SQLite serializes write transactions, so concurrent calls are safely sequenced.
    */
   async atomicInsertWithId(skillWithoutId: Omit<MiniSkill, 'id'>): Promise<MiniSkill> {
-    const result = this.db.transaction(() => {
+    return retrySqliteBusy(async () => this.db.transaction(() => {
       // 1. Read current counter inside the transaction
       const row = this.stmtGetMeta.get('mini_skills_next_id');
       const nextId = row ? parseInt(row.value, 10) : 1;
@@ -239,8 +241,7 @@ export class MiniSkillSqliteStore implements MiniSkillStore {
       this.knownGeneration = this.readGeneration();
 
       return skill;
-    })();
-    return result;
+    })(), 'Mini-skill promotion');
   }
 
   // ── Freshness ────────────────────────────────────────────────────
@@ -266,16 +267,21 @@ export class MiniSkillSqliteStore implements MiniSkillStore {
 // ── Graceful Degrade Fallback ────────────────────────────────────────
 //
 // Phase 2 debt-zero rule: mini-skills have NO writable JSON fallback.
-// In JSON-only environments (no better-sqlite3), reads return empty
-// and writes are no-ops with a warning. This prevents a parallel
-// canonical JSON write path from existing alongside SQLite.
+// In environments without a supported SQLite runtime, reads return an
+// explicit unavailable error and writes fail rather than pretending success.
 
 export class MiniSkillGracefulDegrade implements MiniSkillStore {
   private warned = false;
 
+  constructor(private readonly reason = 'SQLite runtime unavailable') {}
+
+  private unavailableRead(): Error {
+    return degradedReadError('mini-skills');
+  }
+
   private warn(): void {
     if (!this.warned) {
-      console.error('[memorix] MiniSkillStore: SQLite unavailable — mini-skills are disabled (read-only empty). Install better-sqlite3 for full functionality.');
+      console.error('[memorix] MiniSkillStore: SQLite unavailable — mini-skills cannot be read or written. Install a supported SQLite runtime.');
       this.warned = true;
     }
   }
@@ -284,22 +290,23 @@ export class MiniSkillGracefulDegrade implements MiniSkillStore {
     this.warn();
   }
 
-  async loadAll(): Promise<MiniSkill[]> { return []; }
-  async loadByProject(_projectId: string): Promise<MiniSkill[]> { return []; }
-  async loadIdCounter(): Promise<number> { return 1; }
+  async loadAll(): Promise<MiniSkill[]> { throw this.unavailableRead(); }
+  async loadByProject(_projectId: string): Promise<MiniSkill[]> { throw this.unavailableRead(); }
+  async loadIdCounter(): Promise<number> { throw this.unavailableRead(); }
 
-  async insert(_skill: MiniSkill): Promise<void> { this.warn(); }
-  async update(_skill: MiniSkill): Promise<void> { this.warn(); }
-  async remove(_id: number): Promise<void> { this.warn(); }
-  async saveIdCounter(_nextId: number): Promise<void> { /* no-op */ }
+  async insert(_skill: MiniSkill): Promise<void> { this.warn(); throw degradedWriteError('mini-skills'); }
+  async update(_skill: MiniSkill): Promise<void> { this.warn(); throw degradedWriteError('mini-skills'); }
+  async remove(_id: number): Promise<void> { this.warn(); throw degradedWriteError('mini-skills'); }
+  async saveIdCounter(_nextId: number): Promise<void> { this.warn(); throw degradedWriteError('mini-skills'); }
   async atomicInsertWithId(skillWithoutId: Omit<MiniSkill, 'id'>): Promise<MiniSkill> {
     this.warn();
-    return { ...skillWithoutId, id: 0 } as MiniSkill;
+    throw degradedWriteError('mini-skills');
   }
 
   async ensureFresh(): Promise<boolean> { return false; }
   getGeneration(): number { return 0; }
   getBackendName(): 'sqlite' | 'degraded' { return 'degraded'; }
+  getBackendReason(): string { return this.reason; }
 }
 
 // ── Singleton access ────────────────────────────────────────────────
@@ -329,19 +336,21 @@ export async function initMiniSkillStore(dataDir: string): Promise<MiniSkillStor
   _store = null;
   _storeDataDir = null;
 
-  // Try SQLite first
+  // Only a missing SQLite runtime may use the intentional read-only fallback.
+  let degradedReason = 'SQLite runtime unavailable';
   try {
-    const store = new MiniSkillSqliteStore();
-    await store.init(dataDir);
+    const store = await initializeSqliteStore(() => new MiniSkillSqliteStore(), dataDir, 'Mini-skill store');
     _store = store;
     _storeDataDir = dataDir;
     return store;
   } catch (err) {
-    console.error(`[memorix] MiniSkillSqliteStore unavailable, running in degraded read-only mode: ${err instanceof Error ? err.message : err}`);
+    if (!isSqliteUnavailableError(err)) throw err;
+    degradedReason = err instanceof Error ? err.message : String(err);
+    console.error(`[memorix] MiniSkillSqliteStore unavailable, running in degraded read-only mode: ${degradedReason}`);
   }
 
-  // Fallback: graceful degrade (no writable JSON backend per debt-zero rule)
-  const store = new MiniSkillGracefulDegrade();
+  // Fallback: explicit read-only mode (no writable JSON backend per debt-zero rule)
+  const store = new MiniSkillGracefulDegrade(degradedReason);
   await store.init(dataDir);
   _store = store;
   _storeDataDir = dataDir;