feat: Server-side capture storage via PostgreSQL (replaces local filesystem)

Captures are now stored in a `session_captures` DB table instead of
local JSONL files. All operations go through HTTP — no filesystem
dependency on the server.

New/updated endpoints:
- POST /api/captures       — batch-store capture entries
- POST /api/captures/entry — store a single capture entry
- GET  /api/captures/status — buffer status from DB
- POST /api/captures/drain  — drain staged captures into memories

Stack:
- ops/migrate_session_captures.sql — table with RLS + indexes
- ICaptureStore interface + PostgresKnowledgeGraphStore impl
- KnowledgeGraphService.DrainCapturesAsync with tool-type grouping
- SessionCapture model

https://claude.ai/code/session_01M5GUmiM8WehUBUvKWiWgcJ

Author: claude

SerialMemory.Api/Program.cs

@@ -1619,41 +1619,78 @@ await kgService.IngestMemoryAsync(
 });
 
 // ============================================
-// AUTO-CAPTURE API ENDPOINTS
+// AUTO-CAPTURE API ENDPOINTS (server-side DB storage)
 // ============================================
 
-var captureSessionDir = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.UserProfile), ".cc-serialmemory", "sessions");
-
-// Check capture buffer status
-app.MapGet("/api/captures/status", () =>
+// POST capture entries to the server (replaces local JSONL file writes)
+app.MapPost("/api/captures", async (CaptureIngestRequest request, KnowledgeGraphService kgService) =>
 {
-    if (!Directory.Exists(captureSessionDir))
-        return Results.Ok(new { files = 0, totalEntries = 0, message = "No capture directory found" });
+    try
+    {
+        if (request.Entries == null || request.Entries.Count == 0)
+            return Results.BadRequest(new { error = "At least one entry is required" });
+
+        if (request.Entries.Count > 1000)
+            return Results.BadRequest(new { error = "Maximum 1000 entries per request" });
 
-    var files = Directory.GetFiles(captureSessionDir, "*.jsonl")
-        .Where(f => !f.EndsWith(".drained"))
-        .OrderByDescending(File.GetLastWriteTimeUtc)
-        .Select(f =>
+        var captures = request.Entries.Select(e => new SessionCapture
         {
-            var lineCount = File.ReadLines(f).Count(l => !string.IsNullOrWhiteSpace(l));
-            return new
-            {
-                name = Path.GetFileName(f),
-                entries = lineCount,
-                lastModified = File.GetLastWriteTimeUtc(f)
-            };
-        })
-        .ToList();
+            SessionId = request.SessionId ?? e.SessionId,
+            Ts = e.Ts ?? DateTime.UtcNow,
+            Tool = e.Tool,
+            File = e.File,
+            Result = e.Result,
+            RawJson = e.RawJson
+        }).ToList();
 
-    return Results.Ok(new
+        var count = await kgService.StoreCapturesBatchAsync(captures);
+        return Results.Ok(new { stored = count, sessionId = request.SessionId });
+    }
+    catch (Exception ex)
     {
-        files = files.Count,
-        totalEntries = files.Sum(f => f.entries),
-        captures = files
-    });
+        return Results.Problem(detail: ex.Message, statusCode: 500);
+    }
+});
+
+// POST a single capture entry (convenience endpoint)
+app.MapPost("/api/captures/entry", async (CaptureEntryRequest entry, KnowledgeGraphService kgService) =>
+{
+    try
+    {
+        var capture = new SessionCapture
+        {
+            SessionId = entry.SessionId,
+            Ts = entry.Ts ?? DateTime.UtcNow,
+            Tool = entry.Tool,
+            File = entry.File,
+            Result = entry.Result,
+            RawJson = entry.RawJson
+        };
+
+        var id = await kgService.StoreCaptureAsync(capture);
+        return Results.Ok(new { id, stored = true });
+    }
+    catch (Exception ex)
+    {
+        return Results.Problem(detail: ex.Message, statusCode: 500);
+    }
+});
+
+// Check capture buffer status (reads from DB)
+app.MapGet("/api/captures/status", async (KnowledgeGraphService kgService) =>
+{
+    try
+    {
+        var status = await kgService.GetCaptureStatusAsync();
+        return Results.Ok(status);
+    }
+    catch (Exception ex)
+    {
+        return Results.Problem(detail: ex.Message, statusCode: 500);
+    }
 });
 
-// Drain captured JSONL session entries into memories
+// Drain staged captures into memories (reads from DB, marks drained)
 app.MapPost("/api/captures/drain", async (
     string? session_id,
     int? max_entries,
@@ -1662,68 +1699,12 @@ await kgService.IngestMemoryAsync(
 {
     try
     {
-        if (!Directory.Exists(captureSessionDir))
-            return Results.Ok(new { entriesProcessed = 0, memoriesCreated = 0, message = "No capture directory found" });
-
-        // Find session log file
-        string? logFile = null;
-        if (!string.IsNullOrEmpty(session_id))
-        {
-            var specific = Path.Combine(captureSessionDir, $"{session_id}.jsonl");
-            if (File.Exists(specific)) logFile = specific;
-        }
-        logFile ??= Directory.GetFiles(captureSessionDir, "*.jsonl")
-            .Where(f => !f.EndsWith(".drained"))
-            .OrderByDescending(File.GetLastWriteTimeUtc)
-            .FirstOrDefault();
-
-        if (logFile == null)
-            return Results.Ok(new { entriesProcessed = 0, memoriesCreated = 0, message = "No active capture file found" });
-
-        var maxCount = Math.Clamp(max_entries ?? 500, 1, 5000);
-        var lines = File.ReadLines(logFile)
-            .Where(l => !string.IsNullOrWhiteSpace(l))
-            .Take(maxCount)
-            .ToList();
-
-        if (dry_run == true)
-            return Results.Ok(new { entriesFound = lines.Count, dryRun = true, file = Path.GetFileName(logFile) });
+        var result = await kgService.DrainCapturesAsync(
+            sessionId: session_id,
+            maxEntries: max_entries ?? 500,
+            dryRun: dry_run ?? false);
 
-        var memoriesCreated = 0;
-        var errors = 0;
-
-        // Batch lines and ingest as memories
-        foreach (var chunk in lines.Chunk(10))
-        {
-            try
-            {
-                var content = string.Join("\n", chunk);
-                await kgService.IngestMemoryAsync(
-                    content: content,
-                    source: "auto-capture",
-                    metadata: new Dictionary<string, object>
-                    {
-                        ["memory_type"] = "auto_capture",
-                        ["entry_count"] = chunk.Length
-                    },
-                    extractEntities: true,
-                    dedupMode: "off",
-                    memoryType: "auto_capture");
-                memoriesCreated++;
-            }
-            catch { errors++; }
-        }
-
-        // Rename to .drained
-        try { File.Move(logFile, logFile + ".drained", overwrite: true); } catch { }
-
-        return Results.Ok(new
-        {
-            entriesProcessed = lines.Count,
-            memoriesCreated,
-            errors,
-            file = Path.GetFileName(logFile)
-        });
+        return Results.Ok(result);
     }
     catch (Exception ex)
     {
@@ -6889,6 +6870,19 @@ internal record ContextSummarizeRequest(
     int? MaxMemories = 50,
     bool? StoreSummary = true);
 
+// Capture DTOs (server-side DB storage)
+internal record CaptureIngestRequest(
+    string? SessionId,
+    List<CaptureEntryRequest> Entries);
+
+internal record CaptureEntryRequest(
+    string? SessionId = null,
+    DateTime? Ts = null,
+    string? Tool = null,
+    string? File = null,
+    string? Result = null,
+    Dictionary<string, object>? RawJson = null);
+
 // Mutation state holder for tracking pause/resume state (thread-safe)
 internal class MutationStateHolder
 {

SerialMemory.Core/Interfaces/IKnowledgeGraphStore.cs

@@ -101,11 +101,45 @@ public interface IWorkspaceStore
     Task<WorkspaceSnapshot?> GetSnapshotByNameAsync(string workspaceId, string snapshotName, CancellationToken ct = default);
 }
 
+/// <summary>
+/// Server-side session capture staging operations.
+/// Captures are received over HTTP, stored in DB, then drained into memories.
+/// </summary>
+public interface ICaptureStore
+{
+    Task<Guid> InsertCaptureAsync(SessionCapture capture, CancellationToken ct = default);
+    Task<int> InsertCapturesBatchAsync(List<SessionCapture> captures, CancellationToken ct = default);
+    Task<List<SessionCapture>> GetUndrainedCapturesAsync(string? sessionId = null, int limit = 5000, CancellationToken ct = default);
+    Task<int> MarkCapturesDrainedAsync(List<Guid> captureIds, CancellationToken ct = default);
+    Task<CaptureStatusResult> GetCaptureStatusAsync(CancellationToken ct = default);
+}
+
+/// <summary>
+/// Capture buffer status summary.
+/// </summary>
+public class CaptureStatusResult
+{
+    public int TotalUndrained { get; set; }
+    public int TotalDrained { get; set; }
+    public List<CaptureSessionSummary> Sessions { get; set; } = [];
+}
+
+/// <summary>
+/// Per-session capture summary.
+/// </summary>
+public class CaptureSessionSummary
+{
+    public string? SessionId { get; set; }
+    public int EntryCount { get; set; }
+    public DateTime? FirstTs { get; set; }
+    public DateTime? LastTs { get; set; }
+}
+
 /// <summary>
 /// Composite repository interface for knowledge graph operations.
 /// Inherits from focused sub-interfaces for backward compatibility.
 /// </summary>
-public interface IKnowledgeGraphStore : IMemoryStore, IEntityStore, IRelationshipStore, IUserProfileStore, ISessionStore, IStatisticsStore, IWorkspaceStore
+public interface IKnowledgeGraphStore : IMemoryStore, IEntityStore, IRelationshipStore, IUserProfileStore, ISessionStore, IStatisticsStore, IWorkspaceStore, ICaptureStore
 {
     Task<IAsyncDisposable> BeginUnitOfWorkAsync(CancellationToken cancellationToken = default);
 }

SerialMemory.Core/Models/SessionCapture.cs

@@ -0,0 +1,19 @@
+namespace SerialMemory.Core.Models;
+
+/// <summary>
+/// A staged capture entry received over HTTP.
+/// Stored server-side in session_captures table, drained into memories.
+/// </summary>
+public class SessionCapture
+{
+    public Guid Id { get; set; }
+    public string? SessionId { get; set; }
+    public DateTime Ts { get; set; } = DateTime.UtcNow;
+    public string? Tool { get; set; }
+    public string? File { get; set; }
+    public string? Result { get; set; }
+    public Dictionary<string, object>? RawJson { get; set; }
+    public bool Drained { get; set; }
+    public DateTime? DrainedAt { get; set; }
+    public DateTime CreatedAt { get; set; } = DateTime.UtcNow;
+}