gnosys 5.13.0 → 5.13.1

package/dist/cli.js

@@ -1173,9 +1173,16 @@ dreamCmd
     .option("--force", "Run even if this machine is not the designated dream node")
     .option("--scheduled", "Run as the machine-level scheduler (applies night/idle/cooldown gates)")
     .option("--json", "Output raw JSON report")
-    .action(async (opts) => {
+    .action(async function (opts) {
+    // v5.13.1: the bare `gnosys dream` parent declares the same flags, and
+    // commander resolves parent-declared options onto the PARENT during
+    // `dream run --scheduled` — so run's opts arrived empty and every
+    // scheduled invocation (the launchd agent's exact command line) ran as
+    // a MANUAL dream, bypassing the night/idle/dreamworthiness gates.
+    // Merge parent opts (same pattern as `dream log` below).
+    const merged = { ...(this.parent?.opts() ?? {}), ...opts };
     const { runDreamCommand } = await import("./lib/dreamCommand.js");
-    await runDreamCommand(opts);
+    await runDreamCommand(merged);
 });
 // `gnosys dream log` — view recent dream runs from audit_log
 dreamCmd

package/dist/lib/db.d.ts

@@ -330,6 +330,12 @@ export declare class GnosysDB {
         tags: string;
         content: string;
     }>;
+    /**
+     * v5.13.1: top active memories for wildcard recall. The gnosys://recall
+     * resource asks for "the best memories, no query" — rank by how often a
+     * memory proved useful (reinforcement), then confidence, then recency.
+     */
+    getTopActiveMemories(limit?: number): DbMemory[];
     /** v5.13.0: memories whose embedding column is NULL (embedding-health check). */
     countMemoriesMissingEmbedding(): number;
     updateEmbedding(id: string, embedding: Buffer): void;

package/dist/lib/db.js

@@ -1264,6 +1264,15 @@ export class GnosysDB {
         const lim = limit && limit > 0 ? ` LIMIT ${Math.floor(limit)}` : "";
         return this.withRecovery(() => this.prep(`SELECT id, title, relevance, tags, content FROM memories ${where} ORDER BY modified DESC${lim}`).all());
     }
+    /**
+     * v5.13.1: top active memories for wildcard recall. The gnosys://recall
+     * resource asks for "the best memories, no query" — rank by how often a
+     * memory proved useful (reinforcement), then confidence, then recency.
+     */
+    getTopActiveMemories(limit = 15) {
+        return this.withRecovery(() => this.prep(`SELECT ${LEAN_MEMORY_PROJECTION} FROM memories WHERE tier = 'active' AND status = 'active'
+         ORDER BY reinforcement_count DESC, confidence DESC, modified DESC LIMIT ?`).all(limit));
+    }
     /** v5.13.0: memories whose embedding column is NULL (embedding-health check). */
     countMemoriesMissingEmbedding() {
         return this.withRecovery(() => {

package/dist/lib/dreamCommand.js

@@ -1,7 +1,7 @@
 import { GnosysResolver } from "./resolver.js";
 import { GnosysDB } from "./db.js";
 import { loadConfig } from "./config.js";
-import { acquireDreamLock, appendDreamRun, countChangedMemoriesSince, createSkipRunRecord, getSystemIdleMinutes, isInsideNightWindow, readDreamState, } from "./dreamRunLog.js";
+import { acquireDreamLock, appendDreamRun, countDreamworthyChanges, createSkipRunRecord, getSystemIdleMinutes, isInsideNightWindow, readDreamState, } from "./dreamRunLog.js";
 export async function runDreamCommand(opts) {
     const resolver = new GnosysResolver();
     await resolver.resolve();
@@ -15,7 +15,14 @@ export async function runDreamCommand(opts) {
     const { getMachineId } = await import("./remote.js");
     const storePath = stores[0].path;
     const cfg = await loadConfig(storePath);
-    const db = new DbClass(storePath);
+    // v5.13.1: Dream operates on the brain — the central DB — not the
+    // project store the command happened to be run from. Opening
+    // stores[0].path meant `gnosys dream run` failed with "run gnosys
+    // migrate" from any project directory whose local .gnosys has no
+    // migrated DB, even though the central DB was fine (and the designation
+    // check below already used openCentral). DbClass alias keeps the lazy
+    // import pattern.
+    const db = DbClass.openCentral();
     if (!db.isAvailable() || !db.isMigrated()) {
         console.error("Dream Mode requires gnosys.db (v2.0). Run 'gnosys migrate' first.");
         process.exit(1);
@@ -114,7 +121,9 @@ export async function runDreamCommand(opts) {
             gates.push({ name: "system-idle", passed: true, details: { idleMinutes } });
             const state = readDreamState();
             const memories = db.getActiveMemories();
-            const changed = countChangedMemoriesSince(memories, state.lastMemoryMaxModified);
+            // v5.13.1: max(date-watermark changes, count delta) — self-heals
+            // stale/polluted state files and catches bulk imports/deletions.
+            const changed = countDreamworthyChanges(memories, state);
             const lastRunMs = state.lastSuccessfulRunAt ? Date.parse(state.lastSuccessfulRunAt) : 0;
             const hoursSince = lastRunMs ? (Date.now() - lastRunMs) / 3_600_000 : Infinity;
             const enoughMemories = changed >= cfg.dream.minNewMemoriesToDream;

package/dist/lib/dreamRunLog.d.ts

@@ -107,6 +107,16 @@ export declare function memoryWatermark(memories: DbMemory[]): {
     maxModified: string | undefined;
 };
 export declare function countChangedMemoriesSince(memories: DbMemory[], sinceIso?: string): number;
+/**
+ * v5.13.1: total change signal for the dreamworthiness gate. The date-only
+ * watermark misses bulk imports, deletions, and stale/polluted state files
+ * (a test-suite bug wrote lastMemoryCount=5 against 1,200+ memory brains,
+ * suppressing scheduled dreaming indefinitely — fixed in v5.13.0, but
+ * already-polluted machines need the gate itself to self-heal). A mismatch
+ * between the stored memory count and reality IS change — take the max of
+ * both signals.
+ */
+export declare function countDreamworthyChanges(memories: DbMemory[], state: DreamState): number;
 export declare function isInsideNightWindow(now: Date, schedule: DreamConfig["schedule"]): boolean;
 export declare function getSystemIdleMinutes(): number | null;
 export declare function createSkipRunRecord(input: {

package/dist/lib/dreamRunLog.js

@@ -175,6 +175,20 @@ export function countChangedMemoriesSince(memories, sinceIso) {
         return memories.length;
     return memories.filter((m) => Date.parse(m.modified || m.created) > sinceMs).length;
 }
+/**
+ * v5.13.1: total change signal for the dreamworthiness gate. The date-only
+ * watermark misses bulk imports, deletions, and stale/polluted state files
+ * (a test-suite bug wrote lastMemoryCount=5 against 1,200+ memory brains,
+ * suppressing scheduled dreaming indefinitely — fixed in v5.13.0, but
+ * already-polluted machines need the gate itself to self-heal). A mismatch
+ * between the stored memory count and reality IS change — take the max of
+ * both signals.
+ */
+export function countDreamworthyChanges(memories, state) {
+    const byDate = countChangedMemoriesSince(memories, state.lastMemoryMaxModified);
+    const countDelta = state.lastMemoryCount == null ? 0 : Math.abs(memories.length - state.lastMemoryCount);
+    return Math.max(byDate, countDelta);
+}
 export function isInsideNightWindow(now, schedule) {
     const start = schedule.startHour;
     const end = schedule.endHour;

package/dist/lib/recall.js

@@ -23,6 +23,7 @@
 import { GnosysArchive } from "./archive.js";
 import { mergeOverlayDiscoverResults, pendingAddToDbMemory, } from "./clientReadOverlay.js";
 import { auditLog } from "./audit.js";
+import { ftsTerms } from "./ftsQuery.js";
 /** Default recall config */
 const DEFAULT_RECALL_CONFIG = {
     aggressive: true,
@@ -150,6 +151,48 @@ function recallFromDb(query, db, limit, cfg, traceId, pendingOverlay) {
     const memories = [];
     // Step 1: FTS5 discover on gnosys.db
     const fetchLimit = Math.max(limit * 2, 15);
+    // v5.13.1: wildcard recall. The gnosys://recall resource passes "*"
+    // meaning "inject the top memories, no specific query" — but "*" was
+    // never a valid FTS5 match-all (it's a syntax error), so the resource
+    // returned zero memories since it shipped in v4.0.0. Any query with no
+    // searchable terms now serves top active memories ranked by
+    // reinforcement, confidence, and recency.
+    if (ftsTerms(query).length === 0) {
+        const top = db.getTopActiveMemories(fetchLimit);
+        for (let i = 0; i < top.length; i++) {
+            const mem = top[i];
+            memories.push({
+                id: mem.id,
+                title: mem.title,
+                category: mem.category,
+                relevance: mem.relevance || "",
+                confidence: mem.confidence,
+                path: mem.id,
+                fromArchive: false,
+                snippet: mem.content.substring(0, 300),
+                // Rank-derived score, floored above minRelevance (0.4 default) so
+                // non-aggressive mode keeps top memories too.
+                relevanceScore: Math.max(0.9 - i * 0.02, 0.5),
+            });
+        }
+        const wildcardCounts = db.getMemoryCount();
+        const result = applyRecallFiltering(memories, top.length, wildcardCounts.archived, limit, cfg, start);
+        db.logAudit({
+            timestamp: new Date().toISOString(),
+            operation: "recall",
+            memory_id: null,
+            details: JSON.stringify({
+                query,
+                wildcard: true,
+                aggressive: cfg.aggressive,
+                totalCandidates: memories.length,
+                filtered: result.memories.length,
+            }),
+            duration_ms: Math.round(result.recallTimeMs),
+            trace_id: traceId || null,
+        });
+        return result;
+    }
     let dbResults = db.discoverFts(query, fetchLimit);
     if (pendingOverlay?.length) {
         dbResults = mergeOverlayDiscoverResults(dbResults, pendingOverlay, query, fetchLimit, (p) => ({

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gnosys",
-  "version": "5.13.0",
+  "version": "5.13.1",
   "description": "Gnosys — Persistent Memory for AI Agents. Sandbox-first runtime, central SQLite brain, federated search, Dream Mode, Web Knowledge Base, Obsidian export.",
   "type": "module",
   "main": "dist/index.js",