memorix 1.9.1 → 1.9.3

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

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

package/plugins/copilot/memorix/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "memorix",
-  "version": "1.9.1",
+  "version": "1.9.3",
   "description": "Shared local workspace memory for GitHub Copilot CLI and other AI coding agents.",
   "author": {
     "name": "AVIDS2",

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

@@ -1,6 +1,6 @@
 {
   "name": "memorix",
-  "version": "1.9.1",
+  "version": "1.9.3",
   "mcpServers": {
     "memorix": {
       "command": "memorix",

package/plugins/hermes/memorix/plugin.yaml

@@ -1,5 +1,5 @@
 name: memorix
-version: "1.9.1"
+version: "1.9.3"
 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.1",
+  "version": "1.9.3",
   "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.1",
+  "version": "1.9.3",
   "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.1",
+  "version": "1.9.3",
   "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.1",
+  "version": "1.9.3",
   "websiteUrl": "https://mem.rglens.com",
   "icons": [
     {
@@ -22,7 +22,7 @@
     {
       "registryType": "npm",
       "identifier": "memorix",
-      "version": "1.9.1",
+      "version": "1.9.3",
       "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/memory.ts

@@ -280,7 +280,8 @@ export default defineCommand({
         case 'deduplicate': {
           const query = asStringArg(args.query);
           const dryRun = !!args.dryRun || !!args['dry-run'];
-          const { isLLMEnabled } = await import('../../llm/provider.js');
+          const { initLLM, isLLMEnabled } = await import('../../llm/provider.js');
+          initLLM({ scope: 'memory', projectRoot: project.rootPath });
           if (!isLLMEnabled()) {
             emitResult(
               { project, available: false, usedLLM: false },

package/src/cli/default-mode.ts

@@ -0,0 +1,15 @@
+export interface CliInteractivity {
+  stdinIsTTY?: boolean;
+  stdoutIsTTY?: boolean;
+}
+
+/**
+ * MCP hosts start package commands with piped stdio, while a human terminal
+ * has TTYs on both streams. Keep the friendly memcode default for humans and
+ * make the package safe for registry probes and generic MCP launchers.
+ */
+export function shouldDefaultToMcp(options: CliInteractivity = {}): boolean {
+  const stdinIsTTY = options.stdinIsTTY ?? process.stdin.isTTY;
+  const stdoutIsTTY = options.stdoutIsTTY ?? process.stdout.isTTY;
+  return stdinIsTTY !== true || stdoutIsTTY !== true;
+}

package/src/cli/index.ts

@@ -20,6 +20,7 @@ import { importBundledMemcode } from './memcode-bootstrap.js';
 import { installCliPipeErrorGuard } from './pipe-errors.js';
 import { normalizeCliInvocation } from './invocation.js';
 import { printCliGuideForHelp, renderCliGuide } from './command-guide.js';
+import { shouldDefaultToMcp } from './default-mode.js';
 
 installCliPipeErrorGuard();
 
@@ -327,8 +328,16 @@ const main = defineCommand({
       'background', 'bg', 'bs', 'doctor', 'repair', 'dashboard', 'cleanup', 'purge', 'uninstall', 'orchestrate'];
     if (firstArg && knownSubs.includes(firstArg)) return;
 
-    // No subcommand provided — enter memcode TUI (native coding agent)
+    // No subcommand provided — keep the interactive memcode default for a
+    // human terminal, but make piped package launches an MCP server. Generic
+    // MCP directories and clients commonly execute `npx memorix` without
+    // reading server.json's package arguments.
     if (!firstArg) {
+      if (shouldDefaultToMcp()) {
+        const serve = await import('./commands/serve.js');
+        await serve.default.run?.({ args: {}, rawArgs: [], cmd: serve.default } as any);
+        return;
+      }
       try {
         const { runCli } = await importBundledMemcode();
         await runCli(process.argv.slice(2));

package/src/codegraph/lite-provider.ts

@@ -1,5 +1,5 @@
 import { createHash } from 'node:crypto';
-import { readdirSync, readFileSync, statSync, type Dirent } from 'node:fs';
+import { existsSync, readdirSync, readFileSync, statSync, type Dirent } from 'node:fs';
 import { join, relative } from 'node:path';
 import type { CodeEdge, CodeFile, CodeStateSnapshot, CodeSymbol } from './types.js';
 import { collectCodeStateSnapshot } from './code-state.js';
@@ -210,6 +210,14 @@ function resolveMaxFileBytes(value: number | undefined): number {
   return Math.max(1, Math.floor(value!));
 }
 
+function isPythonVirtualenvDir(dir: string): boolean {
+  // PEP 405 virtualenvs place a `pyvenv.cfg` at their root regardless of the
+  // directory name (`.venv`, `.venv-leann`, `env`, uv/poetry envs, ...). Their
+  // `site-packages` trees are large and generated; descending into one can stall
+  // `codegraph refresh`, so skip virtualenvs by this marker rather than by name.
+  return existsSync(join(dir, 'pyvenv.cfg'));
+}
+
 function walk(root: string, exclude: string[], maxFiles: number): string[] {
   const out: string[] = [];
   const visit = (dir: string) => {
@@ -228,6 +236,7 @@ function walk(root: string, exclude: string[], maxFiles: number): string[] {
       if (entry.isDirectory()) {
         if (entry.name === '.git' || entry.name === '.worktrees' || entry.name === '.tmp' || entry.name === 'node_modules') continue;
         if (rel === '.claude/worktrees' || rel.startsWith('.claude/worktrees/')) continue;
+        if (isPythonVirtualenvDir(abs)) continue;
         visit(abs);
         if (out.length >= maxFiles) return;
         continue;

package/src/dashboard/maintenance.ts

@@ -221,6 +221,7 @@ export async function previewConsolidate(context: DashboardMaintenanceContext) {
   const clusters = await findConsolidationCandidates(
     context.projectRoot ?? context.dataDir,
     context.projectId,
+    { store: context.store },
   );
   const payload: ConsolidateTokenPayload = { clusterIds: normalizeClusters(clusters.map((cluster) => cluster.ids)) };
   return {
@@ -248,11 +249,19 @@ export async function executeConsolidate(
   const clusterIds = record.clusterIds.map((ids, index) => payloadIds(ids, `clusterIds[${index}]`));
   const normalized: ConsolidateTokenPayload = { clusterIds: normalizeClusters(clusterIds) };
   verify('consolidate', context.projectId, normalized, token);
-  const current = await findConsolidationCandidates(context.projectRoot ?? context.dataDir, context.projectId);
+  const current = await findConsolidationCandidates(
+    context.projectRoot ?? context.dataDir,
+    context.projectId,
+    { store: context.store },
+  );
   if (JSON.stringify(normalized.clusterIds) !== JSON.stringify(normalizeClusters(current.map((cluster) => cluster.ids)))) {
     throw new DashboardMaintenanceError('Memory changed after the preview. Refresh before consolidating.', 409);
   }
-  const result = await executeConsolidation(context.projectRoot ?? context.dataDir, context.projectId);
+  const result = await executeConsolidation(
+    context.projectRoot ?? context.dataDir,
+    context.projectId,
+    { store: context.store },
+  );
   return { action: 'consolidate', projectId: context.projectId, ...result };
 }
 

package/src/memory/consolidation.ts

@@ -16,7 +16,7 @@
  */
 
 import type { Observation } from '../types.js';
-import { getObservationStore } from '../store/obs-store.js';
+import { getObservationStore, type ObservationStore } from '../store/obs-store.js';
 import { isEligibleForAutomaticDelivery } from './admission.js';
 import { resolveObservationVisibility } from './visibility.js';
 
@@ -108,6 +108,14 @@ interface ConsolidationPage {
   nextCursor?: number;
 }
 
+export interface ConsolidationOptions {
+  threshold?: number;
+  limit?: number;
+  afterId?: number;
+  /** Use a request-scoped store when running inside a multi-project host. */
+  store?: ObservationStore;
+}
+
 function clampBatchSize(limit: number | undefined): number {
   if (!Number.isFinite(limit)) return MAX_BATCH_SIZE;
   return Math.min(MAX_BATCH_SIZE, Math.max(1, Math.floor(limit!)));
@@ -120,10 +128,11 @@ function clampCursor(afterId: number | undefined): number {
 
 async function loadConsolidationPage(
   projectId: string,
-  options: { limit?: number; afterId?: number },
+  options: ConsolidationOptions,
 ): Promise<ConsolidationPage> {
   const limit = clampBatchSize(options.limit);
-  const page = await getObservationStore().loadByProject(projectId, {
+  const store = options.store ?? getObservationStore();
+  const page = await store.loadByProject(projectId, {
     status: 'active',
     afterId: clampCursor(options.afterId),
     limit: limit + 1,
@@ -205,7 +214,7 @@ function findClusters(observations: Observation[], threshold: number): Consolida
 export async function findConsolidationCandidates(
   _projectDir: string,
   projectId: string,
-  opts?: { threshold?: number; limit?: number; afterId?: number },
+  opts?: ConsolidationOptions,
 ): Promise<ConsolidationCluster[]> {
   const threshold = opts?.threshold ?? DEFAULT_SIMILARITY_THRESHOLD;
   const page = await loadConsolidationPage(projectId, opts ?? {});
@@ -224,9 +233,9 @@ export async function findConsolidationCandidates(
 export async function executeConsolidation(
   _projectDir: string,
   projectId: string,
-  opts?: { threshold?: number; limit?: number; afterId?: number },
+  opts?: ConsolidationOptions,
 ): Promise<ConsolidationResult> {
-  const store = getObservationStore();
+  const store = opts?.store ?? getObservationStore();
   const page = await loadConsolidationPage(projectId, opts ?? {});
   const clusters = findClusters(page.observations, opts?.threshold ?? DEFAULT_SIMILARITY_THRESHOLD);
 

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;