squish-memory 1.1.5 → 1.2.0

package/dist/core/runtime/trust-state.js

@@ -0,0 +1,309 @@
+import { getDbClient } from '../lib/db-client.js';
+import { getRecent } from '../memory/memories.js';
+import { getMemoryStats } from '../memory/stats.js';
+import { explainMemory } from '../memory/explain.js';
+import { getLatestProjectWorkingSetSummary, getProjectSignalStats } from '../session/working-set.js';
+import { getGraphStats } from '../graph/index.js';
+import { getAllProjects, getProjectByPath, ensureProject } from '../projects.js';
+import { getProjectPlaces } from '../places/places.js';
+import { getMemoryPlace } from '../places/memory-places.js';
+import { getPlace } from '../places/places.js';
+import { config } from '../../config.js';
+import { getBeliefsForMemory } from '../beliefs/store.js';
+function isLegacyPlaceholderProject(project, currentWorkspacePath) {
+    const normalizedPath = project.path.trim();
+    if (normalizedPath === '.')
+        return true;
+    if (!currentWorkspacePath)
+        return false;
+    return normalizedPath === currentWorkspacePath && String(project.metadata?.source ?? '') === 'mcp';
+}
+function filterNormalOtherProjects(projects, currentProjectId, currentWorkspacePath) {
+    return projects.filter((candidate) => {
+        if (candidate.id === currentProjectId)
+            return false;
+        return !isLegacyPlaceholderProject(candidate, currentWorkspacePath);
+    });
+}
+function inferResolution(project, mode) {
+    if (mode !== 'inferred')
+        return mode;
+    const source = String(project.metadata?.source ?? '');
+    return source === 'mcp' ? 'auto-created' : 'inferred';
+}
+function toProjectSummary(project, mode) {
+    return {
+        id: project.id,
+        name: project.name,
+        path: project.path,
+        resolution: inferResolution(project, mode),
+    };
+}
+export async function resolveProjectScope(projectPath) {
+    const projects = await getAllProjects();
+    const explicitPath = projectPath?.trim();
+    if (explicitPath) {
+        let project = await getProjectByPath(explicitPath);
+        let resolution = 'explicit';
+        if (!project) {
+            project = await ensureProject(explicitPath);
+            resolution = 'auto-created';
+        }
+        if (!project) {
+            throw new Error(`Unable to resolve project: ${explicitPath}`);
+        }
+        return {
+            currentProject: toProjectSummary(project, resolution),
+            otherProjects: filterNormalOtherProjects(projects, project.id, explicitPath)
+                .map((candidate) => toProjectSummary(candidate, 'inferred')),
+            nextStep: null,
+        };
+    }
+    const cwd = process.cwd();
+    const cwdProject = await getProjectByPath(cwd);
+    if (cwdProject) {
+        return {
+            currentProject: toProjectSummary(cwdProject, 'inferred'),
+            otherProjects: filterNormalOtherProjects(projects, cwdProject.id, cwd)
+                .map((candidate) => toProjectSummary(candidate, 'inferred')),
+            nextStep: null,
+        };
+    }
+    if (projects.length === 1) {
+        return {
+            currentProject: toProjectSummary(projects[0], 'inferred'),
+            otherProjects: [],
+            nextStep: null,
+        };
+    }
+    const autoProject = await ensureProject(cwd);
+    if (!autoProject) {
+        throw new Error(`Unable to create project for current workspace: ${cwd}`);
+    }
+    const otherProjects = projects
+        .filter((candidate) => candidate.id !== autoProject.id)
+        .filter((candidate) => !isLegacyPlaceholderProject(candidate, cwd))
+        .map((candidate) => toProjectSummary(candidate, 'inferred'));
+    return {
+        currentProject: toProjectSummary(autoProject, 'auto-created'),
+        otherProjects,
+        nextStep: otherProjects.length > 0
+            ? 'Pass --project with the intended workspace path if this is not the project you meant.'
+            : null,
+    };
+}
+async function getMemoryPlaceName(memoryId) {
+    const placeId = await getMemoryPlace(memoryId);
+    if (!placeId)
+        return null;
+    const place = await getPlace(placeId);
+    return place?.name ?? null;
+}
+export async function buildContextState(projectPath, limit = 10) {
+    const scope = await resolveProjectScope(projectPath);
+    const projectPathResolved = scope.currentProject.path;
+    const [sessionSummary, signalSummary, graphStats, memories] = await Promise.all([
+        getLatestProjectWorkingSetSummary(projectPathResolved),
+        getProjectSignalStats(projectPathResolved),
+        getGraphStats(projectPathResolved),
+        getRecent(projectPathResolved, limit),
+    ]);
+    const project = await getProjectByPath(projectPathResolved);
+    const places = project ? await getProjectPlaces(project.id) : [];
+    const activePlaces = places.filter((place) => place.memoryCount > 0).map((place) => place.name);
+    const durableMemories = await Promise.all(memories.map(async (memory) => ({
+        id: memory.id,
+        type: memory.type,
+        content: memory.content,
+        place: await getMemoryPlaceName(memory.id),
+    })));
+    const beliefRows = await Promise.all(memories.map((memory) => getBeliefsForMemory(memory.id)));
+    const beliefs = beliefRows.flat().slice(0, 6).map((belief) => ({
+        type: belief.type,
+        statement: belief.statement,
+        status: belief.status,
+    }));
+    return {
+        currentProject: scope.currentProject,
+        otherProjects: scope.otherProjects,
+        runtime: {
+            sessionSummary,
+            activePlaces,
+            signalSummary: {
+                captured: signalSummary.captured,
+                suppressed: signalSummary.suppressed,
+                sessionOnly: signalSummary.sessionOnly,
+                durable: signalSummary.durable,
+                durableWithRaw: signalSummary.durableWithRaw,
+            },
+            graphSummary: graphStats.entityCount > 0 || graphStats.relationCount > 0
+                ? `enabled; ${graphStats.entityCount} entities, ${graphStats.relationCount} relations`
+                : 'enabled; no graph enrichments yet',
+        },
+        durableMemories,
+        beliefs,
+        nextStep: scope.nextStep,
+    };
+}
+export async function buildStatsState(projectPath) {
+    const scope = await resolveProjectScope(projectPath);
+    const projectPathResolved = scope.currentProject.path;
+    const [stats, graphStats, sessionSummary] = await Promise.all([
+        getMemoryStats(projectPathResolved),
+        getGraphStats(projectPathResolved),
+        getLatestProjectWorkingSetSummary(projectPathResolved),
+    ]);
+    const project = await getProjectByPath(projectPathResolved);
+    const places = project ? await getProjectPlaces(project.id) : [];
+    return {
+        currentProject: `${scope.currentProject.name} (${scope.currentProject.path})`,
+        totals: {
+            memories: stats.totalMemories,
+            durable: Math.max(stats.totalMemories, (stats.signal?.durable ?? 0) + (stats.signal?.durableWithRaw ?? 0)),
+            sessionLocal: stats.signal?.sessionOnly ?? 0,
+        },
+        signal: {
+            captured: stats.signal?.captured ?? 0,
+            suppressed: stats.signal?.suppressed ?? 0,
+            sessionOnly: stats.signal?.sessionOnly ?? 0,
+            durable: stats.signal?.durable ?? 0,
+            durableWithRaw: stats.signal?.durableWithRaw ?? 0,
+            tokensSaved: stats.signal?.tokensSaved ?? 0,
+            placeRouted: stats.signal?.placeRouted ?? 0,
+            graphEnriched: stats.signal?.graphEnriched ?? 0,
+        },
+        places: {
+            active: places.filter((place) => place.memoryCount > 0).length,
+            named: places.filter((place) => place.memoryCount > 0).map((place) => place.name),
+        },
+        graph: {
+            status: graphStats.entityCount > 0 || graphStats.relationCount > 0 ? 'enabled' : 'enabled (idle)',
+            enrichments: stats.signal?.graphEnriched ?? 0,
+        },
+        wakeUp: sessionSummary || 'No working set yet',
+        signalNote: stats.totalMemories > 0 && (stats.signal?.captured ?? 0) === 0
+            ? 'Signal counts cover capture-era writes only. Legacy durable memories may exist without signal telemetry.'
+            : 'Signal counts cover capture-era writes only.',
+    };
+}
+export async function buildHealthState(projectPath) {
+    const scope = await resolveProjectScope(projectPath);
+    const checks = [];
+    let severity = 'ok';
+    let nextStep = scope.nextStep;
+    try {
+        await getDbClient();
+        checks.push({ name: 'database', status: 'ok', detail: 'Database connection succeeded.' });
+    }
+    catch (error) {
+        severity = 'broken';
+        nextStep = 'Fix database initialization before relying on memory reads or writes.';
+        checks.push({
+            name: 'database',
+            status: 'broken',
+            detail: error?.message ?? 'Database initialization failed.',
+        });
+    }
+    checks.push({
+        name: 'project resolution',
+        status: 'ok',
+        detail: `${scope.currentProject.name} at ${scope.currentProject.path} (${scope.currentProject.resolution})`,
+    });
+    try {
+        await getRecent(scope.currentProject.path, 1);
+        checks.push({ name: 'memory write path', status: 'ok', detail: 'Memory store is readable for this project.' });
+    }
+    catch (error) {
+        severity = severity === 'broken' ? 'broken' : 'degraded';
+        nextStep = nextStep ?? 'Run `squish doctor` to repair local storage before writing memories.';
+        checks.push({
+            name: 'memory write path',
+            status: 'degraded',
+            detail: error?.message ?? 'Memory store could not be read.',
+        });
+    }
+    try {
+        const sessionSummary = await getLatestProjectWorkingSetSummary(scope.currentProject.path);
+        checks.push({
+            name: 'session working set',
+            status: sessionSummary ? 'ok' : 'degraded',
+            detail: sessionSummary || 'No compact working set has been captured yet.',
+        });
+        if (!sessionSummary && severity === 'ok') {
+            severity = 'degraded';
+            nextStep = nextStep ?? 'Run a normal session or memory write so Squish can build a working-set wake-up summary.';
+        }
+    }
+    catch (error) {
+        severity = severity === 'broken' ? 'broken' : 'degraded';
+        checks.push({
+            name: 'session working set',
+            status: 'degraded',
+            detail: error?.message ?? 'Working-set state could not be loaded.',
+        });
+    }
+    const project = await getProjectByPath(scope.currentProject.path);
+    const places = project ? await getProjectPlaces(project.id) : [];
+    const activePlaces = places.filter((place) => place.memoryCount > 0);
+    checks.push({
+        name: 'places',
+        status: activePlaces.length > 0 ? 'ok' : 'degraded',
+        detail: activePlaces.length > 0
+            ? `${activePlaces.length} active places: ${activePlaces.map((place) => place.name).join(', ')}`
+            : 'No populated places yet.',
+    });
+    if (activePlaces.length === 0 && severity === 'ok') {
+        severity = 'degraded';
+        nextStep = nextStep ?? 'Store or recall project memories to populate place routing.';
+    }
+    const graphStats = await getGraphStats(scope.currentProject.path);
+    checks.push({
+        name: 'graph',
+        status: graphStats.entityCount > 0 || graphStats.relationCount > 0 ? 'ok' : 'degraded',
+        detail: graphStats.entityCount > 0 || graphStats.relationCount > 0
+            ? `${graphStats.entityCount} entities and ${graphStats.relationCount} relations available.`
+            : 'Graph is enabled but has no extracted entities yet.',
+    });
+    if (graphStats.entityCount === 0 && graphStats.relationCount === 0 && severity === 'ok') {
+        severity = 'degraded';
+        nextStep = nextStep ?? 'Write or recall durable memories so graph enrichment has material to process.';
+    }
+    checks.push({
+        name: 'mode',
+        status: 'ok',
+        detail: `${config.isManagedMode ? 'managed' : 'local'} mode; embeddings ${config.embeddingsProvider}`,
+    });
+    return {
+        severity,
+        currentProject: `${scope.currentProject.name} (${scope.currentProject.path})`,
+        checks,
+        nextStep,
+    };
+}
+export async function buildInspectState(id) {
+    const inspection = await explainMemory(id);
+    if (!inspection)
+        return null;
+    return {
+        id: inspection.id,
+        classification: inspection.classification,
+        storageReason: inspection.reasons.join('; ') || 'Stored as durable memory.',
+        durability: inspection.classification === 'session-only' ? 'session-only' : 'durable',
+        place: inspection.place ?? null,
+        placeType: inspection.placeType ?? null,
+        graphStatus: inspection.graphStatus ?? null,
+        rawFallback: inspection.rawFallbackSnapshotId ?? null,
+        wakeUpPriority: inspection.nuanceSuppressed ? 'high' : 'normal',
+        metadataAvailability: inspection.legacyMetadata
+            ? 'Legacy durable record; signal-era metadata is unavailable.'
+            : 'Signal metadata available.',
+        beliefs: (inspection.beliefs ?? []).map((belief) => ({
+            id: belief.id,
+            type: belief.type,
+            statement: belief.statement,
+            status: belief.status,
+            confidence: belief.confidence,
+        })),
+    };
+}
+//# sourceMappingURL=trust-state.js.map

package/dist/core/scheduler/cron-scheduler.d.ts

@@ -1,5 +1,5 @@
 /** Cron Scheduler - Persistent cron-based job scheduling with fallback support */
-export type JobType = 'nightly' | 'weekly' | 'hourly';
+export type JobType = 'nightly' | 'weekly' | 'hourly' | 'daily';
 export type JobStatus = 'success' | 'failed' | 'skipped';
 export interface ScheduledJob {
     id: string;

package/dist/core/scheduler/cron-scheduler.js

@@ -1,6 +1,6 @@
 /** Cron Scheduler - Persistent cron-based job scheduling with fallback support */
 import cron from 'node-cron';
-import { selfIterationHandler } from '../session-hooks/self-iteration-job.js';
+import { selfIterationHandler } from '../session/self-iteration-job.js';
 import { runLifecycleMaintenance } from '../lifecycle.js';
 import { logger } from '../logger.js';
 import { config } from '../../config.js';
@@ -8,7 +8,14 @@ import { getDb } from '../../db/index.js';
 import { maintenanceJobs, maintenanceJobHistory } from '../../db/drizzle/schema-sqlite.js';
 import { eq } from 'drizzle-orm';
 const jobHandlers = new Map();
-const activeTasks = new Map();
+const activeTasks = new Map(); // node-cron ScheduledTask type
+// Job interval by type (in ms) - used for catch-up detection
+const JOB_INTERVALS = {
+    hourly: 60 * 60 * 1000, // 1 hour
+    daily: 24 * 60 * 60 * 1000, // 24 hours
+    nightly: 24 * 60 * 60 * 1000, // 24 hours (same as daily)
+    weekly: 7 * 24 * 60 * 60 * 1000, // 7 days
+};
 export function registerJobHandler(jobName, handler) {
     jobHandlers.set(jobName, handler);
     logger.info(`[Scheduler] Registered handler for job: ${jobName}`);
@@ -29,6 +36,67 @@ const decayHandler = async (context) => {
     };
 };
 registerJobHandler('decay_maintenance', decayHandler);
+// Belief decay handler - applies confidence decay to beliefs
+const beliefDecayHandler = async (context) => {
+    const { applyBeliefDecay } = await import('../beliefs/decay.js');
+    const stats = await applyBeliefDecay();
+    return {
+        recordsProcessed: stats.decayed + stats.sourceCountUpdated,
+        summary: {
+            beliefDecayed: stats.decayed,
+            sourceCountUpdated: stats.sourceCountUpdated,
+            errors: stats.errors,
+        },
+    };
+};
+registerJobHandler('belief_decay', beliefDecayHandler);
+// Auto-clean handler - deletes stale memories automatically
+const autoCleanHandler = async (context) => {
+    const { getStaleMemories, deleteMemoryPermanently } = await import('../memory/stale-cleaner.js');
+    const { getAllProjects } = await import('../projects.js');
+    const jobConfig = context.config;
+    if (jobConfig.enabled === false) {
+        return { recordsProcessed: 0, summary: { skipped: true, reason: 'auto-clean disabled' } };
+    }
+    const olderThanDays = jobConfig.olderThanDays || 30;
+    const confidenceLevels = jobConfig.confidenceLevel || ['outdated', 'speculative'];
+    const minImportance = jobConfig.minImportance || 40;
+    const dryRun = jobConfig.dryRun !== undefined ? jobConfig.dryRun : false; // Default to actual delete for safety
+    const projects = await getAllProjects();
+    let totalStale = 0;
+    let totalDeleted = 0;
+    for (const project of projects) {
+        const stale = await getStaleMemories({
+            olderThanDays,
+            confidenceLevels,
+            minImportance,
+            projectId: project.id,
+        });
+        totalStale += stale.length;
+        if (dryRun) {
+            logger.info(`[AutoClean] Would delete ${stale.length} stale memories in ${project.path}`);
+        }
+        else {
+            for (const memory of stale) {
+                if (!memory.isPinned) {
+                    await deleteMemoryPermanently(memory.id);
+                    totalDeleted++;
+                }
+            }
+            logger.info(`[AutoClean] Deleted ${stale.length} stale memories in ${project.path}`);
+        }
+    }
+    return {
+        recordsProcessed: dryRun ? totalStale : totalDeleted,
+        summary: {
+            mode: dryRun ? 'dry-run' : 'deleted',
+            projectsScanned: projects.length,
+            memoriesAffected: dryRun ? totalStale : totalDeleted,
+            criteria: { olderThanDays, confidenceLevels, minImportance },
+        },
+    };
+};
+registerJobHandler('auto_clean', autoCleanHandler);
 export async function initializeScheduler() {
     if (!config.cronEnabled) {
         logger.info('[Scheduler] Cron scheduling disabled, using heartbeat fallback');
@@ -41,6 +109,8 @@ export async function initializeScheduler() {
     }
     try {
         await ensureDefaultJobs(db);
+        // Check for missed jobs (catch-up after machine wake from sleep)
+        await checkMissedJobs();
         const sqliteDb = db;
         const jobs = await sqliteDb
             .select()
@@ -55,6 +125,78 @@ export async function initializeScheduler() {
         logger.error('[Scheduler] Failed to initialize:', error);
     }
 }
+/**
+ * Check for missed jobs and execute catch-up if needed
+ * Called on scheduler initialization (including after machine wake from sleep)
+ */
+async function checkMissedJobs() {
+    try {
+        const db = await getDb();
+        if (!db)
+            return;
+        const sqliteDb = db;
+        const jobs = await sqliteDb
+            .select()
+            .from(maintenanceJobs)
+            .where(eq(maintenanceJobs.enabled, true));
+        const now = Date.now();
+        for (const job of jobs) {
+            const intervalMs = JOB_INTERVALS[job.jobType];
+            if (!intervalMs)
+                continue;
+            const lastRun = job.lastRunAt ? new Date(job.lastRunAt).getTime() : 0;
+            const elapsed = lastRun > 0 ? now - lastRun : intervalMs * 2; // If never run, treat as overdue
+            const gracePeriod = intervalMs * 1.5; // 1.5x interval grace
+            if (elapsed > gracePeriod) {
+                logger.info(`[Scheduler] Catch-up needed for ${job.jobName}, elapsed ${Math.round(elapsed / (60 * 60 * 1000))}h (grace: ${Math.round(gracePeriod / (60 * 60 * 1000))}h)`);
+                // Execute catch-up
+                const handler = jobHandlers.get(job.jobName);
+                if (handler) {
+                    try {
+                        const startedAt = new Date();
+                        const context = {
+                            jobId: job.id,
+                            jobName: job.jobName,
+                            jobType: job.jobType,
+                            config: typeof job.jobConfig === 'string'
+                                ? JSON.parse(job.jobConfig)
+                                : job.jobConfig ?? {},
+                            startedAt,
+                        };
+                        await handler(context);
+                        // Record successful catch-up run
+                        const completedAt = new Date();
+                        await sqliteDb
+                            .update(maintenanceJobs)
+                            .set({
+                            lastRunAt: completedAt,
+                            lastRunStatus: 'success',
+                            lastRunDuration: completedAt.getTime() - startedAt.getTime(),
+                        })
+                            .where(eq(maintenanceJobs.id, job.id));
+                        logger.info(`[Scheduler] Catch-up completed for ${job.jobName}`);
+                    }
+                    catch (catchError) {
+                        const msg = catchError instanceof Error ? catchError.message : String(catchError);
+                        logger.error(`[Scheduler] Catch-up failed for ${job.jobName}:`, msg);
+                        await sqliteDb
+                            .update(maintenanceJobs)
+                            .set({
+                            lastRunAt: new Date(),
+                            lastRunStatus: 'failed',
+                            lastRunError: msg,
+                        })
+                            .where(eq(maintenanceJobs.id, job.id));
+                    }
+                }
+            }
+        }
+    }
+    catch (error) {
+        const msg = error instanceof Error ? error.message : String(error);
+        logger.error('[Scheduler] Error checking missed jobs:', msg);
+    }
+}
 async function ensureDefaultJobs(db) {
     const defaultJobs = [
         {
@@ -64,6 +206,13 @@ async function ensureDefaultJobs(db) {
             enabled: true,
             jobConfig: { applyDecay: true, updateTiers: true, evictOld: true },
         },
+        {
+            jobName: 'belief_decay',
+            jobType: 'daily',
+            cronExpression: '0 4 * * *', // Run daily at 4 AM
+            enabled: true,
+            jobConfig: { applyBeliefDecay: true },
+        },
         {
             jobName: 'nightly_maintenance',
             jobType: 'nightly',
@@ -85,6 +234,19 @@ async function ensureDefaultJobs(db) {
             enabled: true,
             jobConfig: { minMessageCount: 5, maxMessagesToProcess: 50 },
         },
+        {
+            jobName: 'auto_clean',
+            jobType: 'daily',
+            cronExpression: '0 3 * * *', // Run daily at 3 AM
+            enabled: true,
+            jobConfig: {
+                enabled: true,
+                olderThanDays: 30,
+                confidenceLevel: ['outdated', 'speculative'],
+                minImportance: 40,
+                dryRun: true, // Start with dry-run for safety
+            },
+        },
     ];
     for (const job of defaultJobs) {
         let existing;
@@ -167,7 +329,6 @@ export async function scheduleJob(job) {
     const task = cron.schedule(job.cronExpression, async () => {
         await executeJob(job);
     }, {
-        scheduled: true,
         timezone: 'UTC',
     });
     activeTasks.set(job.jobName, task);

package/dist/core/scheduler/job-runner.js

@@ -15,8 +15,8 @@ export async function runNightlyJob(context) {
         try {
             const lifecycleResult = await runLifecycleMaintenance();
             summary.decayApplied = lifecycleResult?.decayed || 0;
+            // Simplified: hot/cold only (warm removed)
             summary.tiersUpdated = (lifecycleResult?.tierChanges?.hot || 0) +
-                (lifecycleResult?.tierChanges?.warm || 0) +
                 (lifecycleResult?.tierChanges?.cold || 0);
             recordsProcessed += summary.decayApplied;
             recordsProcessed += summary.tiersUpdated;

package/dist/core/search/qmd-wrapper.d.ts

@@ -0,0 +1,36 @@
+import { type QMDSearchResult } from '../embeddings/qmd-client.js';
+export type { QMDSearchResult };
+export interface QMDStatus {
+    indexHealth: string;
+    documentCount: number;
+    collections?: Array<{
+        name: string;
+        path: string;
+        documentCount: number;
+    }>;
+}
+export declare function isAvailable(): Promise<boolean>;
+export declare function search(query: string, options?: {
+    collection?: string;
+    limit?: number;
+    minScore?: number;
+}): Promise<QMDSearchResult[]>;
+export declare function vsearch(query: string, options?: {
+    collection?: string;
+    limit?: number;
+    minScore?: number;
+}): Promise<QMDSearchResult[]>;
+export declare function query(queryText: string, options?: {
+    collection?: string;
+    limit?: number;
+    minScore?: number;
+}): Promise<QMDSearchResult[]>;
+export declare function get(pathOrDocid: string, options?: {
+    full?: boolean;
+    maxBytes?: number;
+}): Promise<string>;
+export declare function status(): Promise<QMDStatus | null>;
+export declare function embed(): Promise<number[] | null>;
+export declare function ensureWikiDir(projectPath: string): Promise<string>;
+export declare function close(): Promise<void>;
+//# sourceMappingURL=qmd-wrapper.d.ts.map

package/dist/core/search/qmd-wrapper.js

@@ -0,0 +1,58 @@
+import { getQMDClient } from '../embeddings/qmd-client.js';
+export async function isAvailable() {
+    const client = await getQMDClient();
+    return client.isAvailable();
+}
+export async function search(query, options = {}) {
+    const client = await getQMDClient();
+    if (!(await client.isAvailable()))
+        return [];
+    return client.search({ query, ...options });
+}
+export async function vsearch(query, options = {}) {
+    const client = await getQMDClient();
+    if (!(await client.isAvailable()))
+        return [];
+    return client.vsearch({ query, ...options });
+}
+export async function query(queryText, options = {}) {
+    const client = await getQMDClient();
+    if (!(await client.isAvailable()))
+        return [];
+    return client.query({ query: queryText, ...options });
+}
+export async function get(pathOrDocid, options = {}) {
+    const client = await getQMDClient();
+    if (!(await client.isAvailable()))
+        return '';
+    return client.get({ pathOrDocid, ...options });
+}
+export async function status() {
+    const client = await getQMDClient();
+    if (!(await client.isAvailable()))
+        return null;
+    const result = await client.status();
+    if (!result)
+        return null;
+    return {
+        indexHealth: result.indexHealth,
+        documentCount: result.collections.reduce((sum, collection) => sum + collection.documentCount, 0),
+        collections: result.collections,
+    };
+}
+export async function embed() {
+    return null;
+}
+export async function ensureWikiDir(projectPath) {
+    const { join } = await import('path');
+    const { mkdirSync, existsSync } = await import('fs');
+    const wikiDir = join(projectPath, '.squish', 'wiki');
+    if (!existsSync(wikiDir))
+        mkdirSync(wikiDir, { recursive: true });
+    return wikiDir;
+}
+export async function close() {
+    const client = await getQMDClient();
+    await client.disconnect();
+}
+//# sourceMappingURL=qmd-wrapper.js.map

package/dist/core/session/auto-load.js

@@ -6,9 +6,9 @@ import { search } from '../memory/memories.js';
 import { getProjectContext } from '../context/context.js';
 import { getOrCreateProject } from '../projects.js';
 import { DEFAULT_AUTO_LOAD_CONFIG } from './types.js';
-function estimateTokens(text) {
-    return Math.ceil(text.length / 4);
-}
+import { estimateTokens } from '../context/context-window.js';
+import { getLatestProjectWorkingSetSummary } from './working-set.js';
+import { getHotCacheSummary } from '../hot-cache.js';
 export async function performAutoLoad(projectPath, customConfig) {
     const startTime = Date.now();
     const cfg = { ...DEFAULT_AUTO_LOAD_CONFIG, ...customConfig };
@@ -33,6 +33,31 @@ export async function performAutoLoad(projectPath, customConfig) {
             return result;
         }
         const projectId = project.id;
+        try {
+            const workingSetSummary = await getLatestProjectWorkingSetSummary(projectPath);
+            if (workingSetSummary) {
+                result.tokensUsed += estimateTokens(workingSetSummary);
+            }
+        }
+        catch (error) {
+            const msg = error instanceof Error ? error.message : String(error);
+            result.warnings.push(`Failed to load session working set: ${msg}`);
+        }
+        // NEW: Load persistent hot cache (Karpathy-style, survives restart)
+        if (cfg.includeCoreMemory) {
+            try {
+                const hotCacheSummary = await getHotCacheSummary({ projectPath, maxEntries: 5 });
+                if (hotCacheSummary) {
+                    result.tokensUsed += estimateTokens(hotCacheSummary);
+                    logger.info('[AutoLoad] Hot cache loaded from persistent storage');
+                }
+            }
+            catch (error) {
+                const msg = error instanceof Error ? error.message : String(error);
+                result.warnings.push(`Failed to load hot cache: ${msg}`);
+                logger.warn(`[AutoLoad] Failed to load hot cache: ${msg}`);
+            }
+        }
         if (cfg.includeCoreMemory) {
             try {
                 await initializeCoreMemory(projectId);