squish-memory 1.0.2 → 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,19 +1,102 @@
 /** 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';
 import { getDb } from '../../db/index.js';
-import { maintenanceJobs, maintenanceJobHistory } from '../../drizzle/schema-sqlite.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}`);
 }
 // Register self-iteration job handler
 registerJobHandler('self_iteration', selfIterationHandler);
+// Decay job handler - runs lifecycle maintenance (decay, tier updates, eviction)
+const decayHandler = async (context) => {
+    const stats = await runLifecycleMaintenance();
+    return {
+        recordsProcessed: stats.decayed + stats.expired + stats.evicted,
+        summary: {
+            decayed: stats.decayed,
+            expired: stats.expired,
+            evicted: stats.evicted,
+            tierChanges: stats.tierChanges,
+        },
+    };
+};
+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');
@@ -26,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()
@@ -40,8 +125,94 @@ 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 = [
+        {
+            jobName: 'decay_maintenance',
+            jobType: 'hourly',
+            cronExpression: '0 * * * *', // Run every hour at :00
+            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',
@@ -63,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;
@@ -110,12 +294,12 @@ async function ensureDefaultJobs(db) {
                 logger.warn(`[Scheduler] Drizzle insert failed, using raw SQL: ${insertError.message}`);
                 const rawDb = db.$client;
                 if (rawDb && typeof rawDb.prepare === 'function') {
-                    const stmt = rawDb.prepare(`
-            INSERT INTO maintenance_jobs 
-            (id, job_name, job_type, cron_expression, enabled, job_config, 
-             total_runs, success_count, failure_count, last_run_at, next_run_at, 
-             last_run_duration, last_run_status, last_run_error)
-            VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+                    const stmt = rawDb.prepare(`
+            INSERT INTO maintenance_jobs 
+            (id, job_name, job_type, cron_expression, enabled, job_config, 
+             total_runs, success_count, failure_count, last_run_at, next_run_at, 
+             last_run_duration, last_run_status, last_run_error)
+            VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
           `);
                     stmt.run(crypto.randomUUID(), job.jobName, job.jobType, job.cronExpression, job.enabled ? 1 : 0, JSON.stringify(job.jobConfig), 0, 0, 0, null, null, null, null, null);
                 }
@@ -145,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/index.d.ts

@@ -1,6 +1,6 @@
 /**
  * Scheduler Module
- * v0.10.0 - Cron-based job scheduling with heartbeat fallback
+ * Cron-based job scheduling with heartbeat fallback
  */
 export * from './cron-scheduler.js';
 export * from './heartbeat.js';

package/dist/core/scheduler/index.js

@@ -1,6 +1,6 @@
 /**
  * Scheduler Module
- * v0.10.0 - Cron-based job scheduling with heartbeat fallback
+ * Cron-based job scheduling with heartbeat fallback
  */
 export * from './cron-scheduler.js';
 export * from './heartbeat.js';

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

@@ -5,7 +5,7 @@ import { runLifecycleMaintenance } from '../lifecycle.js';
 import { pruneWeakAssociations } from '../associations.js';
 import { pruneOldSummaries } from '../summarization.js';
 import { getDb } from '../../db/index.js';
-import { memories, memoryFeedback } from '../../drizzle/schema-sqlite.js';
+import { memories, memoryFeedback } from '../../db/drizzle/schema-sqlite.js';
 import { eq, and, gt, lt } from 'drizzle-orm';
 export async function runNightlyJob(context) {
     const summary = {};
@@ -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;