memorix 1.2.1 → 1.2.2

package/src/runtime/maintenance-jobs.ts

@@ -8,6 +8,7 @@ export const MAINTENANCE_JOB_KINDS = [
   'retention-archive',
   'consolidation',
   'codegraph-refresh',
+  'observation-qualify',
   'claim-derive',
   'claim-requalification',
   'knowledge-compile',

package/src/runtime/maintenance-runner.ts

@@ -3,6 +3,7 @@ import { loadDotenv } from '../config/dotenv-loader.js';
 import { initProjectRoot } from '../config/yaml-loader.js';
 import { initLLM } from '../llm/provider.js';
 import { initObservationStore } from '../store/obs-store.js';
+import { initObservations } from '../memory/observations.js';
 import {
   MAINTENANCE_JOB_KINDS,
   type MaintenanceJob,
@@ -58,6 +59,7 @@ export async function executeMaintenanceRequest(
   initProjectRoot(request.projectRoot);
   loadDotenv(request.projectRoot);
   await initObservationStore(request.dataDir);
+  await initObservations(request.dataDir);
   if (request.job.kind === 'consolidation') initLLM();
 
   const handler = createProjectMaintenanceHandler(

package/src/runtime/project-maintenance.ts

@@ -6,6 +6,7 @@ import { runMaintenanceInChildProcess } from './isolated-maintenance.js';
 import {
   enqueueClaimRequalification,
   enqueueKnowledgeFollowups,
+  enqueueObservationQualification,
   type MaintenanceQueue,
 } from './lifecycle.js';
 
@@ -14,6 +15,7 @@ const DEFAULT_RETENTION_BATCH_SIZE = 100;
 const DEFAULT_CONSOLIDATION_BATCH_SIZE = 200;
 const DEFAULT_CODEGRAPH_MAX_FILES = 5_000;
 const DEFAULT_CLAIM_DERIVATION_BATCH_SIZE = 100;
+const DEFAULT_OBSERVATION_QUALIFICATION_BATCH_SIZE = 100;
 const VECTOR_RETRY_DELAY_MS = 5_000;
 const DEDUP_PER_PAIR_TIMEOUT_MS = 5_000;
 
@@ -68,6 +70,19 @@ function claimDerivationCursor(payload: Record<string, unknown>): number {
     : 0;
 }
 
+function observationQualificationBatchSize(payload: Record<string, unknown>): number {
+  const value = payload.limit;
+  if (typeof value !== 'number' || !Number.isFinite(value)) return DEFAULT_OBSERVATION_QUALIFICATION_BATCH_SIZE;
+  return Math.min(500, Math.max(1, Math.floor(value)));
+}
+
+function observationQualificationCursor(payload: Record<string, unknown>): number {
+  const value = payload.cursor;
+  return typeof value === 'number' && Number.isFinite(value)
+    ? Math.max(0, Math.floor(value))
+    : 0;
+}
+
 function observationId(payload: Record<string, unknown>): number | undefined {
   const value = payload.observationId;
   return typeof value === 'number' && Number.isSafeInteger(value) && value > 0
@@ -275,6 +290,80 @@ export function createProjectMaintenanceHandler(
         ...(snapshot?.id ? { snapshotId: snapshot.id } : {}),
         ...(options.maintenanceQueue ? { queue: options.maintenanceQueue } : {}),
       });
+      enqueueObservationQualification({
+        projectId,
+        dataDir: projectDir,
+        source: 'codegraph-refresh',
+        ...(options.maintenanceQueue ? { queue: options.maintenanceQueue } : {}),
+      });
+      return { action: 'complete' };
+    }
+
+    if (job.kind === 'observation-qualify') {
+      const [
+        { CodeGraphStore },
+        { bindObservationToCode },
+        { getObservationStore },
+        { qualifyCandidateFromCurrentCode },
+        { updateObservationAdmission },
+      ] = await Promise.all([
+        import('../codegraph/store.js'),
+        import('../codegraph/binder.js'),
+        import('../store/obs-store.js'),
+        import('../memory/admission.js'),
+        import('../memory/observations.js'),
+      ]);
+      const codeStore = new CodeGraphStore();
+      await codeStore.init(projectDir);
+      const limit = observationQualificationBatchSize(job.payload);
+      const page = await getObservationStore().loadByProject(projectId, {
+        status: 'active',
+        afterId: observationQualificationCursor(job.payload),
+        limit: limit + 1,
+      });
+      const hasMore = page.length > limit;
+      const observations = hasMore ? page.slice(0, limit) : page;
+      const indexedAtMs = Date.parse(codeStore.status(projectId).indexedAt ?? '');
+
+      for (const observation of observations) {
+        if (observation.admissionState !== 'candidate') continue;
+        // A candidate may only earn delivery after a Code Memory scan that
+        // happened at or after it was captured. A stale snapshot is evidence
+        // about an earlier project state, not a reason to inject this record.
+        if (!Number.isFinite(indexedAtMs) || indexedAtMs < Date.parse(observation.createdAt)) continue;
+        await bindObservationToCode(codeStore, observation);
+        const currentCodeReferenceCount = codeStore
+          .listObservationRefs(projectId, observation.id)
+          .filter((reference) => reference.status === 'current')
+          .length;
+        const qualification = qualifyCandidateFromCurrentCode({
+          observation,
+          currentCodeReferenceCount,
+        });
+        if (!qualification) continue;
+        await updateObservationAdmission({
+          observationId: observation.id,
+          projectId,
+          expectedState: 'candidate',
+          // Automatic capture earns project visibility only after a current
+          // Code Memory link exists. Explicit/private records retain scope.
+          ...(observation.sourceDetail === 'hook' ? { visibility: 'project' as const } : {}),
+          ...qualification,
+        });
+      }
+
+      if (hasMore && observations.length > 0) {
+        return {
+          action: 'reschedule',
+          delayMs: 0,
+          resetAttempts: true,
+          payload: {
+            ...job.payload,
+            cursor: observations[observations.length - 1].id,
+            limit,
+          },
+        };
+      }
       return { action: 'complete' };
     }