gnosys 5.11.3 → 5.12.0

package/dist/lib/dreamRunLog.js

@@ -0,0 +1,212 @@
+import { execFileSync } from "child_process";
+import crypto from "crypto";
+import fs from "fs";
+import os from "os";
+import path from "path";
+import { getGnosysHome } from "./paths.js";
+const DEFAULT_STATE = {
+    analyzedFingerprints: {},
+};
+const MODEL_PRICES_USD_PER_MILLION = {
+    "grok-4.3": { input: 3, output: 15 },
+    "grok-4.20": { input: 3, output: 15 },
+    "grok-4": { input: 3, output: 15 },
+    "claude-sonnet-4-6": { input: 3, output: 15 },
+    "claude-haiku-4-5": { input: 1, output: 5 },
+    "gpt-5.4-mini": { input: 0.25, output: 2 },
+    "gpt-5.4-nano": { input: 0.05, output: 0.4 },
+    "mistral-small-4": { input: 0.2, output: 0.6 },
+};
+export function getDreamRunsPath() {
+    return path.join(getGnosysHome(), "dream-runs.jsonl");
+}
+export function getDreamStatePath() {
+    return path.join(getGnosysHome(), "dream-state.json");
+}
+export function getDreamLockPath() {
+    return path.join(getGnosysHome(), "dream.lock");
+}
+export function acquireDreamLock() {
+    const lockPath = getDreamLockPath();
+    fs.mkdirSync(path.dirname(lockPath), { recursive: true });
+    try {
+        const fd = fs.openSync(lockPath, "wx");
+        fs.writeFileSync(fd, JSON.stringify({ pid: process.pid, startedAt: new Date().toISOString() }));
+        fs.closeSync(fd);
+        return {
+            acquired: true,
+            release: () => {
+                try {
+                    fs.unlinkSync(lockPath);
+                }
+                catch {
+                    // Best effort: stale lock cleanup happens on the next acquire.
+                }
+            },
+        };
+    }
+    catch {
+        try {
+            const raw = fs.readFileSync(lockPath, "utf8");
+            const parsed = JSON.parse(raw);
+            if (parsed.pid && !isProcessRunning(parsed.pid)) {
+                fs.unlinkSync(lockPath);
+                return acquireDreamLock();
+            }
+            return { acquired: false, reason: `dream already running (pid ${parsed.pid || "unknown"})` };
+        }
+        catch {
+            return { acquired: false, reason: "dream already running (lock exists)" };
+        }
+    }
+}
+function isProcessRunning(pid) {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export function estimateTokens(text) {
+    return Math.max(1, Math.ceil(text.length / 4));
+}
+export function estimateCost(model, inputTokens, outputTokens) {
+    const key = (model || "").toLowerCase();
+    const exact = MODEL_PRICES_USD_PER_MILLION[key];
+    const fuzzy = exact ?? Object.entries(MODEL_PRICES_USD_PER_MILLION).find(([m]) => key.includes(m))?.[1];
+    if (!fuzzy)
+        return 0;
+    const cost = (inputTokens / 1_000_000) * fuzzy.input + (outputTokens / 1_000_000) * fuzzy.output;
+    return Math.round(cost * 1_000_000) / 1_000_000;
+}
+export function readDreamState() {
+    try {
+        const raw = fs.readFileSync(getDreamStatePath(), "utf8");
+        const parsed = JSON.parse(raw);
+        return {
+            ...DEFAULT_STATE,
+            ...parsed,
+            analyzedFingerprints: parsed.analyzedFingerprints ?? {},
+        };
+    }
+    catch {
+        return { ...DEFAULT_STATE };
+    }
+}
+export function writeDreamState(state) {
+    const file = getDreamStatePath();
+    fs.mkdirSync(path.dirname(file), { recursive: true });
+    fs.writeFileSync(file, `${JSON.stringify(state, null, 2)}\n`, "utf8");
+}
+export function appendDreamRun(record) {
+    const file = getDreamRunsPath();
+    fs.mkdirSync(path.dirname(file), { recursive: true });
+    fs.appendFileSync(file, `${JSON.stringify(record)}\n`, "utf8");
+}
+export function readDreamRuns(opts = {}) {
+    const file = getDreamRunsPath();
+    if (!fs.existsSync(file))
+        return [];
+    const sinceMs = opts.sinceIso ? Date.parse(opts.sinceIso) : null;
+    const rows = fs.readFileSync(file, "utf8")
+        .split(/\r?\n/)
+        .filter(Boolean)
+        .map((line) => {
+        try {
+            return JSON.parse(line);
+        }
+        catch {
+            return null;
+        }
+    })
+        .filter((row) => !!row)
+        .filter((row) => !opts.status || row.status === opts.status)
+        .filter((row) => sinceMs == null || Date.parse(row.startedAt) >= sinceMs)
+        .sort((a, b) => Date.parse(b.startedAt) - Date.parse(a.startedAt));
+    return typeof opts.limit === "number" ? rows.slice(0, opts.limit) : rows;
+}
+export function fingerprintMemories(kind, memories) {
+    const material = memories
+        .map((m) => `${m.id}:${m.modified}:${m.content_hash || ""}`)
+        .sort()
+        .join("|");
+    return `${kind}:${crypto.createHash("sha256").update(material).digest("hex").slice(0, 24)}`;
+}
+export function memoryWatermark(memories) {
+    const maxModified = memories
+        .map((m) => m.modified || m.created)
+        .filter(Boolean)
+        .sort()
+        .at(-1);
+    return { count: memories.length, maxModified };
+}
+export function countChangedMemoriesSince(memories, sinceIso) {
+    if (!sinceIso)
+        return memories.length;
+    const sinceMs = Date.parse(sinceIso);
+    if (!Number.isFinite(sinceMs))
+        return memories.length;
+    return memories.filter((m) => Date.parse(m.modified || m.created) > sinceMs).length;
+}
+export function isInsideNightWindow(now, schedule) {
+    const start = schedule.startHour;
+    const end = schedule.endHour;
+    const hour = now.getHours();
+    if (start === end)
+        return true;
+    if (start < end)
+        return hour >= start && hour < end;
+    return hour >= start || hour < end;
+}
+export function getSystemIdleMinutes() {
+    if (process.platform !== "darwin")
+        return null;
+    try {
+        const output = execFileSync("ioreg", ["-c", "IOHIDSystem"], { encoding: "utf8", timeout: 2000 });
+        const match = output.match(/HIDIdleTime"\s*=\s*(\d+)/);
+        if (!match)
+            return null;
+        const nanoseconds = Number(match[1]);
+        return nanoseconds / 1_000_000_000 / 60;
+    }
+    catch {
+        return null;
+    }
+}
+export function createSkipRunRecord(input) {
+    const finishedAt = input.finishedAt ?? new Date().toISOString();
+    return {
+        id: `dream-${Date.parse(input.startedAt)}-${Math.random().toString(36).slice(2, 8)}`,
+        trigger: input.trigger,
+        status: "skipped",
+        startedAt: input.startedAt,
+        finishedAt,
+        durationMs: Math.max(0, Date.parse(finishedAt) - Date.parse(input.startedAt)),
+        machine: { hostname: os.hostname(), machineId: input.machineId },
+        provider: input.provider,
+        model: input.model,
+        gates: input.gates,
+        phases: [],
+        llmCalls: [],
+        totals: {
+            llmCallsMade: 0,
+            llmCallsSkipped: 0,
+            estimatedInputTokens: 0,
+            estimatedOutputTokens: 0,
+            estimatedCostUsd: 0,
+        },
+        effectiveness: {
+            usefulOutputScore: 0,
+            costPerUsefulOutput: null,
+            decaysApplied: 0,
+            summariesGenerated: 0,
+            summariesUpdated: 0,
+            reviewSuggestions: 0,
+            relationshipsDiscovered: 0,
+        },
+        errors: [],
+        skipReason: input.reason,
+    };
+}

package/dist/lib/embeddings.js

@@ -45,6 +45,9 @@ export class GnosysEmbeddings {
         // Dynamic import — keeps @huggingface/transformers out of the main bundle.
         // dtype 'q8' replaces the v2-era `quantized: true` option (8-bit quantized,
         // ~80 MB vs ~280 MB for fp32). Smaller is fine for sentence embeddings.
+        // Use `any` here so `tsc` succeeds even when the optional dep is not installed
+        // (CI network-share-simulation job, fresh checkouts, etc.). The real type
+        // is only needed at runtime when the package is present.
         let pipeline;
         try {
             ({ pipeline } = await import("@huggingface/transformers"));

package/dist/lib/exportCommand.d.ts

@@ -0,0 +1,18 @@
+export type VaultExportOptions = {
+    to: string;
+    all?: boolean;
+    overwrite?: boolean;
+    summaries?: boolean;
+    reviews?: boolean;
+    graph?: boolean;
+    json?: boolean;
+};
+export type ProjectExportOptions = {
+    to: string;
+    includeArchived?: boolean;
+    audit?: boolean;
+    json?: boolean;
+};
+export declare function runExportUsageCommand(): void;
+export declare function runVaultExportCommand(opts: VaultExportOptions): Promise<void>;
+export declare function runProjectExportCommand(projectIdArg: string | undefined, opts: ProjectExportOptions): Promise<void>;

package/dist/lib/exportCommand.js

@@ -0,0 +1,101 @@
+import path from "path";
+import { GnosysResolver } from "./resolver.js";
+export function runExportUsageCommand() {
+    console.error("Usage: gnosys export vault --to <dir>             # Obsidian vault export");
+    console.error("       gnosys export project [id] --to <bundle>   # portable .json.gz bundle");
+    process.exit(1);
+}
+export async function runVaultExportCommand(opts) {
+    const resolver = new GnosysResolver();
+    await resolver.resolve();
+    const stores = resolver.getStores();
+    if (stores.length === 0) {
+        console.error("No Gnosys stores found. Run 'gnosys init' first.");
+        process.exit(1);
+    }
+    const { GnosysDB: DbClass } = await import("./db.js");
+    const { GnosysExporter, formatExportReport } = await import("./export.js");
+    const storePath = stores[0].path;
+    let db = null;
+    try {
+        db = new DbClass(storePath);
+        if (!db.isAvailable() || !db.isMigrated()) {
+            console.error("Export requires gnosys.db (v2.0). Run 'gnosys migrate' first.");
+            process.exitCode = 1;
+            return;
+        }
+        const targetDir = path.resolve(opts.to);
+        console.error(`Exporting to: ${targetDir}`);
+        const exporter = new GnosysExporter(db);
+        const report = await exporter.export({
+            targetDir,
+            activeOnly: !opts.all,
+            includeSummaries: opts.summaries !== false,
+            includeReviews: opts.reviews !== false,
+            includeGraph: opts.graph !== false,
+            overwrite: opts.overwrite || false,
+            onProgress: (current, total, file) => {
+                if (current % 10 === 0 || current === total) {
+                    console.error(`  [${current}/${total}] ${file}`);
+                }
+            },
+        });
+        if (opts.json) {
+            console.log(JSON.stringify(report, null, 2));
+        }
+        else {
+            console.log(formatExportReport(report));
+        }
+    }
+    finally {
+        db?.close();
+    }
+}
+export async function runProjectExportCommand(projectIdArg, opts) {
+    const { GnosysDB: DbClass } = await import("./db.js");
+    const { exportProject } = await import("./exportProject.js");
+    let centralDb = null;
+    try {
+        centralDb = DbClass.openCentral();
+        if (!centralDb.isAvailable()) {
+            console.error("Central DB unavailable.");
+            process.exitCode = 1;
+            return;
+        }
+        let projectId = projectIdArg;
+        if (!projectId) {
+            const proj = centralDb.getProjectByDirectory(process.cwd());
+            if (!proj) {
+                console.error("No project ID given and current directory is not a registered project.");
+                console.error("Usage: gnosys export project <projectId> --to <file>");
+                process.exitCode = 1;
+                return;
+            }
+            projectId = proj.id;
+        }
+        const result = exportProject(centralDb, {
+            projectId,
+            outputPath: path.resolve(opts.to),
+            includeArchived: !!opts.includeArchived,
+            includeAudit: opts.audit !== false,
+        });
+        if (opts.json) {
+            console.log(JSON.stringify(result, null, 2));
+        }
+        else {
+            const ratio = (result.compressedBytes / result.uncompressedBytes * 100).toFixed(1);
+            console.log(`Exported project ${projectId}`);
+            console.log(`  Memories:      ${result.memoryCount}`);
+            if (result.archivedExcluded > 0) {
+                console.log(`  Archived:      ${result.archivedExcluded} excluded — re-run with --include-archived for a full backup`);
+            }
+            console.log(`  Relationships: ${result.relationshipCount}`);
+            console.log(`  Audit entries: ${result.auditEntryCount}`);
+            console.log(`  Bundle:        ${result.outputPath}`);
+            console.log(`  Size:          ${(result.compressedBytes / 1024).toFixed(1)} KB compressed (${ratio}% of ${(result.uncompressedBytes / 1024).toFixed(1)} KB)`);
+        }
+    }
+    finally {
+        centralDb?.close();
+    }
+}

package/dist/lib/fsearchCommand.d.ts

@@ -0,0 +1,8 @@
+export type FsearchCommandOptions = {
+    limit: string;
+    directory?: string;
+    global: boolean;
+    scope?: string;
+    json: boolean;
+};
+export declare function runFsearchCommand(query: string, opts: FsearchCommandOptions): Promise<void>;

package/dist/lib/fsearchCommand.js

@@ -0,0 +1,44 @@
+export async function runFsearchCommand(query, opts) {
+    const { resolveClientRead } = await import("./clientReadResolve.js");
+    const resolved = resolveClientRead();
+    if (!resolved) {
+        console.error("Central DB not available.");
+        process.exit(1);
+    }
+    try {
+        const { federatedSearch, detectCurrentProject } = await import("./federated.js");
+        const projectId = await detectCurrentProject(resolved.db, opts.directory || undefined);
+        const scopeFilter = opts.scope ? opts.scope.split(",").map(s => s.trim()) : undefined;
+        const results = federatedSearch(resolved.db, query, {
+            limit: parseInt(opts.limit, 10),
+            projectId,
+            includeGlobal: opts.global,
+            scopeFilter,
+        });
+        if (opts.json) {
+            console.log(JSON.stringify({ query, projectId, count: results.length, results }, null, 2));
+        }
+        else {
+            if (results.length === 0) {
+                console.log(`No results for "${query}".`);
+                return;
+            }
+            const ctx = projectId ? `Context: project ${projectId}` : "No project detected";
+            console.log(ctx);
+            for (const [i, r] of results.entries()) {
+                const proj = r.projectName ? ` [${r.projectName}]` : "";
+                console.log(`\n${i + 1}. ${r.title} (${r.category})${proj}`);
+                console.log(`   scope: ${r.scope} | score: ${r.score.toFixed(4)} | boosts: ${r.boosts.join(", ")}`);
+                if (r.snippet)
+                    console.log(`   ${r.snippet.substring(0, 120)}`);
+            }
+        }
+    }
+    catch (err) {
+        console.error(`Error: ${err instanceof Error ? err.message : err}`);
+        process.exit(1);
+    }
+    finally {
+        resolved.release();
+    }
+}

package/dist/lib/graphCommand.d.ts

@@ -0,0 +1,4 @@
+export type GraphCommandOptions = {
+    json?: boolean;
+};
+export declare function runGraphCommand(opts: GraphCommandOptions): Promise<void>;

package/dist/lib/graphCommand.js

@@ -0,0 +1,68 @@
+import { buildLinkGraph, formatGraphSummary } from "./wikilinks.js";
+import { GnosysDB } from "./db.js";
+function outputResult(json, data, humanFn) {
+    if (json) {
+        console.log(JSON.stringify(data, null, 2));
+    }
+    else {
+        humanFn();
+    }
+}
+export async function runGraphCommand(opts) {
+    let centralDb = null;
+    try {
+        centralDb = GnosysDB.openCentral();
+        if (!centralDb.isAvailable()) {
+            console.error("Central DB not available.");
+            process.exit(1);
+        }
+        const dbMemories = centralDb.getAllMemories();
+        if (dbMemories.length === 0) {
+            outputResult(!!opts.json, { totalLinks: 0, orphanedLinks: [], nodes: [] }, () => {
+                console.log("No memories found.");
+            });
+            return;
+        }
+        const adapted = dbMemories.map((m) => {
+            let parsedTags = [];
+            try {
+                parsedTags = JSON.parse(m.tags);
+            }
+            catch {
+                parsedTags = [];
+            }
+            const relativePath = `${m.category}/${m.id}.md`;
+            return {
+                frontmatter: {
+                    id: m.id,
+                    title: m.title,
+                    category: m.category,
+                    tags: parsedTags,
+                    relevance: m.relevance,
+                    author: m.author,
+                    authority: m.authority,
+                    confidence: m.confidence,
+                    created: m.created,
+                    modified: m.modified,
+                    last_reviewed: m.modified,
+                    status: m.status,
+                    supersedes: m.supersedes,
+                },
+                content: m.content,
+                filePath: relativePath,
+                relativePath,
+            };
+        });
+        const graph = buildLinkGraph(adapted);
+        outputResult(!!opts.json, {
+            totalLinks: graph.totalLinks,
+            orphanedLinks: graph.orphanedLinks,
+            nodes: Array.from(graph.nodes.values()),
+        }, () => {
+            console.log(formatGraphSummary(graph));
+        });
+    }
+    finally {
+        centralDb?.close();
+    }
+}

package/dist/lib/helperGenerateCommand.d.ts

@@ -0,0 +1,5 @@
+export type HelperGenerateCommandOptions = {
+    directory?: string;
+    json?: boolean;
+};
+export declare function runHelperGenerateCommand(opts: HelperGenerateCommandOptions): Promise<void>;

package/dist/lib/helperGenerateCommand.js

@@ -0,0 +1,27 @@
+export async function runHelperGenerateCommand(opts) {
+    try {
+        const { generateHelper } = await import("../sandbox/helper-template.js");
+        const targetDir = opts.directory || process.cwd();
+        const outputPath = await generateHelper(targetDir);
+        if (opts.json) {
+            console.log(JSON.stringify({ ok: true, path: outputPath }));
+        }
+        else {
+            console.log(`Generated: ${outputPath}`);
+            console.log();
+            console.log("Usage in your agent/script:");
+            console.log('  import { gnosys } from "./gnosys-helper";');
+            console.log('  await gnosys.add("We use conventional commits");');
+            console.log('  const ctx = await gnosys.recall("auth decisions");');
+        }
+    }
+    catch (err) {
+        if (opts.json) {
+            console.log(JSON.stringify({ ok: false, error: err instanceof Error ? err.message : String(err) }));
+        }
+        else {
+            console.error(`Failed to generate helper: ${err instanceof Error ? err.message : err}`);
+        }
+        process.exit(1);
+    }
+}

package/dist/lib/historyCommand.d.ts

@@ -0,0 +1,5 @@
+export type HistoryCommandOptions = {
+    limit: string;
+    json?: boolean;
+};
+export declare function runHistoryCommand(memoryPath: string, opts: HistoryCommandOptions): Promise<void>;

package/dist/lib/historyCommand.js

@@ -0,0 +1,51 @@
+import { GnosysDB } from "./db.js";
+function outputResult(json, data, humanFn) {
+    if (json) {
+        console.log(JSON.stringify(data, null, 2));
+    }
+    else {
+        humanFn();
+    }
+}
+export async function runHistoryCommand(memoryPath, opts) {
+    const centralDb = GnosysDB.openCentral();
+    if (!centralDb.isAvailable()) {
+        console.error("Central DB not available.");
+        process.exit(1);
+    }
+    try {
+        const dbMem = centralDb.getMemory(memoryPath);
+        if (!dbMem) {
+            console.error(`Memory not found: ${memoryPath}`);
+            process.exit(1);
+        }
+        const limit = parseInt(opts.limit, 10) || 20;
+        const audits = centralDb.getAuditLog(dbMem.id, limit);
+        outputResult(!!opts.json, {
+            memoryId: dbMem.id,
+            title: dbMem.title,
+            created: dbMem.created,
+            modified: dbMem.modified,
+            entries: audits,
+        }, () => {
+            if (audits.length === 0) {
+                console.log(`Memory: ${dbMem.title} (${dbMem.id})`);
+                console.log(`Created: ${dbMem.created}`);
+                console.log(`Modified: ${dbMem.modified}`);
+                console.log("No audit history recorded.");
+                return;
+            }
+            console.log(`History for ${dbMem.title} (${dbMem.id}, ${audits.length} entries):\n`);
+            console.log(`Created: ${dbMem.created}`);
+            console.log(`Modified: ${dbMem.modified}\n`);
+            for (const entry of audits) {
+                const date = entry.timestamp.split("T")[0];
+                const detail = entry.details ? ` (${entry.details})` : "";
+                console.log(`  ${date}  ${entry.operation}${detail}`);
+            }
+        });
+    }
+    finally {
+        centralDb.close();
+    }
+}

package/dist/lib/hybridSearchCommand.d.ts

@@ -0,0 +1,12 @@
+import type { GnosysResolver } from "./resolver.js";
+export type HybridSearchCommandOptions = {
+    limit: string;
+    mode: string;
+    json?: boolean;
+    federated?: boolean;
+    scope?: string;
+    directory?: string;
+};
+type GetResolver = () => Promise<GnosysResolver>;
+export declare function runHybridSearchCommand(getResolver: GetResolver, query: string, opts: HybridSearchCommandOptions): Promise<void>;
+export {};

package/dist/lib/hybridSearchCommand.js

@@ -0,0 +1,95 @@
+import { GnosysSearch } from "./search.js";
+function outputResult(json, data, humanFn) {
+    if (json) {
+        console.log(JSON.stringify(data, null, 2));
+    }
+    else {
+        humanFn();
+    }
+}
+export async function runHybridSearchCommand(getResolver, query, opts) {
+    // Federated path — uses central DB
+    if (opts.federated || opts.scope) {
+        const { resolveClientRead } = await import("./clientReadResolve.js");
+        const resolved = resolveClientRead();
+        if (!resolved) {
+            console.error("Central DB not available.");
+            process.exit(1);
+        }
+        try {
+            const { federatedSearch, detectCurrentProject } = await import("./federated.js");
+            const projectId = await detectCurrentProject(resolved.db, opts.directory || undefined);
+            const scopeFilter = opts.scope ? opts.scope.split(",").map(s => s.trim()) : undefined;
+            const results = federatedSearch(resolved.db, query, {
+                limit: parseInt(opts.limit, 10),
+                projectId,
+                scopeFilter,
+            });
+            outputResult(!!opts.json, { query, projectId, mode: "federated", count: results.length, results }, () => {
+                if (results.length === 0) {
+                    console.log(`No results for "${query}".`);
+                    return;
+                }
+                console.log(`Found ${results.length} results for "${query}" (mode: federated):\n`);
+                for (const [i, r] of results.entries()) {
+                    const proj = r.projectName ? ` [${r.projectName}]` : "";
+                    console.log(`${i + 1}. ${r.title} (${r.category})${proj}`);
+                    console.log(`   scope: ${r.scope} | score: ${r.score.toFixed(4)} | boosts: ${r.boosts.join(", ")}`);
+                    if (r.snippet)
+                        console.log(`   ${r.snippet.substring(0, 120)}`);
+                }
+            });
+        }
+        catch (err) {
+            console.error(`Error: ${err instanceof Error ? err.message : err}`);
+            process.exit(1);
+        }
+        finally {
+            resolved.release();
+        }
+        return;
+    }
+    // Legacy file-based hybrid search
+    const resolver = await getResolver();
+    const stores = resolver.getStores();
+    if (stores.length === 0) {
+        console.error("No stores found.");
+        process.exit(1);
+    }
+    const storePath = stores[0].path;
+    const search = new GnosysSearch(storePath);
+    search.clearIndex();
+    for (const s of stores) {
+        await search.addStoreMemories(s.store, s.label);
+    }
+    const { GnosysEmbeddings } = await import("./embeddings.js");
+    const { GnosysHybridSearch } = await import("./hybridSearch.js");
+    const embeddings = new GnosysEmbeddings(storePath);
+    const hybridSearch = new GnosysHybridSearch(search, embeddings, resolver, storePath);
+    const mode = opts.mode;
+    const results = await hybridSearch.hybridSearch(query, parseInt(opts.limit), mode);
+    if (results.length === 0) {
+        outputResult(!!opts.json, { query, mode, results: [] }, () => {
+            console.log(`No results for "${query}". Try gnosys reindex to build embeddings.`);
+        });
+    }
+    else {
+        outputResult(!!opts.json, { query, mode, count: results.length, results }, () => {
+            console.log(`Found ${results.length} results for "${query}" (mode: ${mode}):\n`);
+            for (const r of results) {
+                console.log(`  ${r.title}`);
+                console.log(`    Path: ${r.relativePath}`);
+                console.log(`    Score: ${r.score.toFixed(4)} (via: ${r.sources.join("+")})`);
+                console.log(`    ${r.snippet.substring(0, 120)}...\n`);
+            }
+        });
+        // Reinforce used memories (best-effort)
+        const writeTarget = resolver.getWriteTarget();
+        if (writeTarget) {
+            const { GnosysMaintenanceEngine } = await import("./maintenance.js");
+            await GnosysMaintenanceEngine.reinforceBatch(writeTarget.store, results.map((r) => r.relativePath)).catch(() => { });
+        }
+    }
+    search.close();
+    embeddings.close();
+}