revert: remove unused Agent PostgreSQL persistence

src/learning/stateStore.ts

@@ -1,6 +1,11 @@
-import { type QueryResultRow } from "pg";
+import { join } from "node:path";
 
-import { AgentDatabase, getAgentDatabase } from "../db/index.js";
+import { config } from "../config.js";
+import {
+  atomicWriteJson,
+  ensureDirectory,
+  readJsonFile,
+} from "../utils/fileStore.js";
 
 export type LearningSessionState = {
   lastGatedTurn: number;
@@ -10,65 +15,32 @@ export type LearningSessionState = {
   updatedAt: string;
 };
 
-type LearningStateRow = QueryResultRow & {
-  session_id: string;
-  last_gated_turn: number;
-  last_reviewed_turn: number;
-  pending_review: boolean;
-  updated_at: Date | string;
-};
-
 export class LearningStateStore {
-  constructor(private readonly db: AgentDatabase = getAgentDatabase()) {}
+  constructor(private readonly baseDir = config.LEARNING_STATE_STORAGE_DIR) {}
 
   async initialize() {
-    await this.db.initialize();
+    await ensureDirectory(this.baseDir);
   }
 
   async read(sessionId: string): Promise<LearningSessionState> {
-    const result = await this.db.query<LearningStateRow>(
-      `
-        SELECT session_id, last_gated_turn, last_reviewed_turn, pending_review, updated_at
-        FROM ${this.db.table("learning_states")}
-        WHERE session_id = $1
-        LIMIT 1
-      `,
-      [sessionId],
-    );
-    return (
-      mapLearningStateRow(result.rows[0]) ?? {
-        lastGatedTurn: 0,
-        lastReviewedTurn: 0,
-        pendingReview: false,
-        sessionId,
-        updatedAt: new Date(0).toISOString(),
-      }
-    );
+    const existing = await readJsonFile<LearningSessionState>(this.filePath(sessionId));
+    if (existing) {
+      return existing;
+    }
+    return {
+      lastGatedTurn: 0,
+      lastReviewedTurn: 0,
+      pendingReview: false,
+      sessionId,
+      updatedAt: new Date(0).toISOString(),
+    };
   }
 
   async write(state: LearningSessionState) {
-    await this.db.query(
-      `
-        INSERT INTO ${this.db.table("learning_states")} (
-          session_id,
-          last_gated_turn,
-          last_reviewed_turn,
-          pending_review
-        )
-        VALUES ($1, $2, $3, $4)
-        ON CONFLICT (session_id)
-        DO UPDATE SET
-          last_gated_turn = EXCLUDED.last_gated_turn,
-          last_reviewed_turn = EXCLUDED.last_reviewed_turn,
-          pending_review = EXCLUDED.pending_review
-      `,
-      [
-        state.sessionId,
-        state.lastGatedTurn,
-        state.lastReviewedTurn,
-        state.pendingReview,
-      ],
-    );
+    await atomicWriteJson(this.filePath(state.sessionId), {
+      ...state,
+      updatedAt: new Date().toISOString(),
+    });
   }
 
   async markPending(sessionId: string, pendingReview: boolean) {
@@ -97,17 +69,8 @@ export class LearningStateStore {
       pendingReview: false,
     });
   }
-}
 
-const mapLearningStateRow = (row?: LearningStateRow | null): LearningSessionState | null => {
-  if (!row) {
-    return null;
+  private filePath(sessionId: string) {
+    return join(this.baseDir, `${sessionId}.json`);
   }
-  return {
-    sessionId: row.session_id,
-    lastGatedTurn: row.last_gated_turn,
-    lastReviewedTurn: row.last_reviewed_turn,
-    pendingReview: row.pending_review,
-    updatedAt: row.updated_at instanceof Date ? row.updated_at.toISOString() : row.updated_at,
-  };
-};
+}