@shadowforge0/aquifer-memory 1.8.1 → 1.9.1

package/core/backends/local.js

@@ -3,6 +3,7 @@
 const fs = require('fs/promises');
 const path = require('path');
 const { backendCapabilities, unsupportedCapabilityError } = require('./capabilities');
+const { buildBacklogProductStatus, buildReadinessSurface } = require('../interface');
 
 function emptyStore() {
   const now = new Date().toISOString();
@@ -299,6 +300,115 @@ function createLocalAquifer(config = {}) {
     async memoryBootstrap() {
       unsupported('memoryBootstrap', 'curatedBootstrap');
     },
+    doctor: {
+      async run() {
+        return {
+          ok: false,
+          status: 'warn',
+          checks: [
+            {
+              id: 'backend',
+              status: 'warn',
+              summary: 'Local starter backend is running with degraded governance coverage.',
+              details: {
+                backendKind: 'local',
+                backendProfile: capabilities.profile,
+                backendPath,
+                capabilities: capabilities.capabilities,
+              },
+              nextAction: capabilities.upgradeHint,
+            },
+            {
+              id: 'db',
+              status: 'warn',
+              summary: 'PostgreSQL governance ledgers are unavailable on the local starter backend.',
+              details: {
+                configured: false,
+                tenantId,
+              },
+              nextAction: 'Use the PostgreSQL backend for migrations, finalization ledgers, and operator workflows.',
+            },
+          ],
+        };
+      },
+    },
+    finalization: {
+      async list() {
+        unsupported('finalization list', 'finalizationLedger');
+      },
+      async inspect() {
+        unsupported('finalization inspect', 'finalizationLedger');
+      },
+    },
+    operator: {
+      async status() {
+        return {
+          readOnly: true,
+          compaction: {
+            available: false,
+            latest: [],
+            staleClaims: [],
+            statusCounts: {},
+            error: 'operator compaction ledger is unavailable on the local starter backend',
+          },
+          checkpoint: {
+            available: false,
+            latest: [],
+            statusCounts: {},
+            error: 'operator checkpoint ledger is unavailable on the local starter backend',
+          },
+        };
+      },
+      async inspect() {
+        unsupported('operator inspect', 'operatorCompaction');
+      },
+    },
+    memory: {
+      async explainBootstrap() {
+        unsupported('explain bootstrap', 'curatedBootstrap');
+      },
+      async explainCurrent() {
+        unsupported('explain memory', 'curatedRecall');
+      },
+      async explainMemory() {
+        unsupported('explain memory', 'curatedRecall');
+      },
+    },
+    review: {
+      async queue() {
+        return {
+          readOnly: true,
+          derived: true,
+          available: false,
+          items: [],
+          reviewQueue: [],
+          scope: {
+            activeScopeKey: null,
+            activeScopePath: [],
+          },
+          filters: {},
+          summary: {
+            scanned: 0,
+            queued: 0,
+            truncated: false,
+            severityCounts: {},
+            feedbackTypeCounts: {},
+          },
+          totals: {
+            items: 0,
+            issueFeedback: 0,
+            allFeedback: 0,
+          },
+          error: 'Memory review queue is unavailable on the local starter backend',
+        };
+      },
+      async inspect() {
+        unsupported('review inspect', 'curatedRecall');
+      },
+      async resolve() {
+        unsupported('review resolve', 'curatedRecall');
+      },
+    },
     async historicalBootstrap(opts = {}) {
       return this.bootstrap(opts);
     },
@@ -311,7 +421,7 @@ function createLocalAquifer(config = {}) {
         counts[status] = (counts[status] || 0) + 1;
       }
       const dates = sessions.map(s => s.startedAt).filter(Boolean).sort();
-      return {
+      const stats = {
         backendKind: 'local',
         backendProfile: capabilities.profile,
         serving: {
@@ -345,6 +455,64 @@ function createLocalAquifer(config = {}) {
         degraded: true,
         capabilities: capabilities.capabilities,
       };
+      return {
+        ...stats,
+        readiness: buildReadinessSurface(stats, {
+          checks: [
+            {
+              key: 'backend',
+              status: 'ready',
+              label: 'Service',
+              message: 'Aquifer is online.',
+            },
+            {
+              key: 'historical_memory',
+              status: sessions.length > 0 ? 'ready' : 'empty',
+              label: 'Saved content',
+              message: sessions.length > 0
+                ? 'Saved local content is available.'
+                : 'No saved content is available yet.',
+            },
+            {
+              key: 'current_memory',
+              status: 'not_supported',
+              label: 'Memory',
+              message: 'Complete memory requires full storage.',
+            },
+          ],
+        }),
+      };
+    },
+    async getPendingWork(opts = {}) {
+      const publicStatus = buildBacklogProductStatus({ statusCounts: {} });
+      return {
+        available: true,
+        generatedAt: new Date().toISOString(),
+        terminalFiltering: false,
+        filters: {
+          source: opts.source || null,
+          agentId: opts.agentId || null,
+          statuses: opts.status ? [String(opts.status)] : ['pending', 'failed'],
+          limit: Math.max(1, Math.min(500, opts.limit || 100)),
+        },
+        total: 0,
+        status: 'clear',
+        statusCounts: {},
+        summary: 'All saved content is ready.',
+        nextStep: 'No action required.',
+        publicStatus,
+        groups: [],
+        samples: [],
+        guidance: [],
+        plan: {
+          action: opts.action || opts.plan || 'inspect',
+          dryRunOnly: true,
+          allowed: 0,
+          blocked: 0,
+          changes: [],
+          notes: ['Local backend has no asynchronous pending/failed session backlog.'],
+        },
+      };
     },
     async getPendingSessions() {
       return [];