sensorium-mcp 2.17.27 → 3.0.0

package/supervisor/updater.go

@@ -4,21 +4,31 @@ import (
 	"context"
 	"encoding/json"
 	"fmt"
+	"io"
 	"net/http"
 	"os"
 	"path/filepath"
 	"runtime"
 	"strings"
+	"syscall"
 	"time"
 )
 
 const registryURL = "https://registry.npmjs.org/sensorium-mcp/latest"
+const supervisorReleaseURL = "https://api.github.com/repos/andriyshevchenko/remote-copilot-mcp/releases/tags/supervisor-latest"
+
+var (
+	notifyUpdaterOperator      = NotifyOperator
+	mcpUpdateReadyPollInterval = 3 * time.Second
+	mcpUpdateReadyTimeout      = 60 * time.Second
+)
 
 // Updater checks the npm registry for new versions and performs updates.
 type Updater struct {
 	cfg     Config
 	mcp     *MCPClient
 	log     *Logger
+	state   *UpdateStateStore
 	startAt time.Time
 	cancel  context.CancelFunc
 	done    chan struct{}
@@ -29,6 +39,7 @@ func NewUpdater(cfg Config, mcp *MCPClient, log *Logger) *Updater {
 		cfg:     cfg,
 		mcp:     mcp,
 		log:     log,
+		state:   NewUpdateStateStore(cfg.Paths.UpdateState, log),
 		startAt: time.Now(),
 		done:    make(chan struct{}),
 	}
@@ -75,6 +86,10 @@ func (u *Updater) run(ctx context.Context) {
 		}
 
 		u.checkAndUpdate(ctx)
+		if ctx.Err() != nil {
+			return
+		}
+		u.checkSupervisorUpdate(ctx)
 	}
 }
 
@@ -159,30 +174,54 @@ func (u *Updater) checkAndUpdate(ctx context.Context) {
 	}
 
 	u.log.Info("Update available: %s → %s", local, remote)
-	NotifyOperator(u.cfg, u.log, fmt.Sprintf("⚙️ Supervisor: updating sensorium v%s → v%s. Grace period %v...", local, remote, u.cfg.GracePeriod), 0)
+	coordLock, ok := AcquireUpdateCoordinatorLock(u.cfg.Paths.UpdateApplyLock, updateScopeMCP, u.log)
+	if !ok {
+		u.log.Info("Deferring MCP update %s → %s due to active update apply lock", local, remote)
+		return
+	}
+	defer coordLock.Release()
+
+	u.state.Transition(updateScopeMCP, updatePhaseApplying, remote, local, "")
+	markFailed := func(err error) {
+		u.state.Transition(updateScopeMCP, updatePhaseFailed, remote, local, err.Error())
+	}
+
+	notifyUpdaterOperator(u.cfg, u.log, fmt.Sprintf("⚙️ Supervisor: updating sensorium v%s → v%s. Grace period %v...", local, remote, u.cfg.GracePeriod), 0)
 
 	// Grace period
 	u.log.Info("Grace period %v...", u.cfg.GracePeriod)
 	select {
 	case <-ctx.Done():
+		markFailed(ctx.Err())
 		return
 	case <-time.After(u.cfg.GracePeriod):
 	}
 
-	// Set maintenance flag — always clean up on exit
-	if err := atomicWrite(u.cfg.Paths.MaintenanceFlag, []byte(time.Now().Format(time.RFC3339))); err != nil {
+	// Set maintenance flag — always clean up on exit.
+	// Written as JSON so TypeScript's checkMaintenanceFlag() can parse the
+	// version and timestamp fields for accurate maintenance notifications.
+	maintenanceJSON, err := json.Marshal(map[string]string{
+		"version":   remote,
+		"timestamp": time.Now().Format(time.RFC3339),
+	})
+	if err != nil {
+		u.log.Warn("Failed to marshal maintenance flag: %v", err)
+	} else if err := atomicWrite(u.cfg.Paths.MaintenanceFlag, maintenanceJSON); err != nil {
 		u.log.Warn("Failed to write maintenance flag: %v", err)
 	}
 	defer os.Remove(u.cfg.Paths.MaintenanceFlag)
 
 	// Kill the current MCP server
 	if ctx.Err() != nil {
+		markFailed(ctx.Err())
 		return
 	}
+	u.state.Transition(updateScopeMCP, updatePhaseRestarting, remote, local, "")
 	u.killServer()
 
 	// Clean npx cache
 	if ctx.Err() != nil {
+		markFailed(ctx.Err())
 		return
 	}
 	u.clearNpxCache()
@@ -191,6 +230,7 @@ func (u *Updater) checkAndUpdate(ctx context.Context) {
 	var pid int
 	for attempt := 1; attempt <= 3; attempt++ {
 		if ctx.Err() != nil {
+			markFailed(ctx.Err())
 			return
 		}
 		pid, err = SpawnMCPServer(u.cfg, u.log)
@@ -204,26 +244,287 @@ func (u *Updater) checkAndUpdate(ctx context.Context) {
 	}
 	if err != nil {
 		u.log.Error("All spawn attempts failed — server is down!")
-		NotifyOperator(u.cfg, u.log, "🔴 Supervisor: update FAILED — server is down! Manual intervention required.", 0)
+		markFailed(err)
+		notifyUpdaterOperator(u.cfg, u.log, "🔴 Supervisor: update FAILED — server is down! Manual intervention required.", 0)
 		return
 	}
 
-	// Wait for new server to be ready
-	if u.mcp.WaitForReady(ctx, 3*time.Second, 60*time.Second) {
-		u.log.Info("Updated MCP server ready (PID %d)", pid)
-	} else {
-		u.log.Warn("Updated server did not become ready in 60s")
+	if !u.verifyUpdatedMCPServerReady(ctx, remote, local, pid) {
+		return
 	}
 
 	u.setLocalVersion(remote)
+	u.state.Transition(updateScopeMCP, updatePhaseIdle, remote, local, "")
 
-	NotifyOperator(u.cfg, u.log, fmt.Sprintf("✅ Supervisor: update to v%s complete. Server ready.", remote), 0)
+	notifyUpdaterOperator(u.cfg, u.log, fmt.Sprintf("✅ Supervisor: update to v%s complete. Server ready.", remote), 0)
 	u.log.Info("Update complete: v%s → v%s", local, remote)
 
 	// Reset start time for min uptime tracking
 	u.startAt = time.Now()
 }
 
+func (u *Updater) verifyUpdatedMCPServerReady(ctx context.Context, remote, local string, pid int) bool {
+	u.state.Transition(updateScopeMCP, updatePhaseVerifying, remote, local, "")
+	if u.mcp.WaitForReady(ctx, mcpUpdateReadyPollInterval, mcpUpdateReadyTimeout) {
+		u.log.Info("Updated MCP server ready (PID %d)", pid)
+		return true
+	}
+
+	errMsg := fmt.Sprintf("updated MCP server did not become ready within %v after restart (pid=%d)", mcpUpdateReadyTimeout, pid)
+	u.log.Error(errMsg)
+	u.state.Transition(updateScopeMCP, updatePhaseFailed, remote, local, errMsg)
+	notifyUpdaterOperator(u.cfg, u.log, fmt.Sprintf("🔴 Supervisor: update to v%s FAILED verification. Server did not become ready after restart.", remote), 0)
+	return false
+}
+
+type githubRelease struct {
+	TagName string `json:"tag_name"`
+	Name    string `json:"name"`
+	Assets  []struct {
+		Name string `json:"name"`
+		URL  string `json:"browser_download_url"`
+		Size int64  `json:"size"`
+	} `json:"assets"`
+}
+
+func (u *Updater) getSupervisorRelease(ctx context.Context) (string, string, error) {
+	ctx2, cancel := context.WithTimeout(ctx, 20*time.Second)
+	defer cancel()
+
+	req, err := http.NewRequestWithContext(ctx2, http.MethodGet, supervisorReleaseURL, nil)
+	if err != nil {
+		return "", "", err
+	}
+	req.Header.Set("Accept", "application/vnd.github+json")
+	req.Header.Set("User-Agent", "sensorium-supervisor-updater")
+
+	resp, err := http.DefaultClient.Do(req)
+	if err != nil {
+		return "", "", err
+	}
+	defer resp.Body.Close()
+
+	if resp.StatusCode != http.StatusOK {
+		return "", "", fmt.Errorf("GitHub releases HTTP %d", resp.StatusCode)
+	}
+
+	var release githubRelease
+	if err := json.NewDecoder(resp.Body).Decode(&release); err != nil {
+		return "", "", err
+	}
+
+	assetName := supervisorAssetName()
+	for _, asset := range release.Assets {
+		if asset.Name != assetName {
+			continue
+		}
+
+		version := strings.TrimSpace(release.Name)
+		if version == "" {
+			version = strings.TrimSpace(release.TagName)
+		}
+		if version == "" {
+			return "", "", fmt.Errorf("release version missing for %s", assetName)
+		}
+		if strings.TrimSpace(asset.URL) == "" {
+			return "", "", fmt.Errorf("release asset URL missing for %s", assetName)
+		}
+
+		return version, asset.URL, nil
+	}
+
+	return "", "", fmt.Errorf("release asset %q not found", assetName)
+}
+
+func supervisorAssetName() string {
+	suffix := ""
+	if runtime.GOOS == "windows" {
+		suffix = ".exe"
+	}
+	return fmt.Sprintf("sensorium-supervisor-%s-%s%s", runtime.GOOS, runtime.GOARCH, suffix)
+}
+
+func (u *Updater) getLocalSupervisorVersion() string {
+	data, err := os.ReadFile(u.cfg.Paths.SupervisorVersion)
+	if err != nil {
+		return ""
+	}
+	return strings.TrimSpace(string(data))
+}
+
+func (u *Updater) setLocalSupervisorVersion(v string) {
+	os.MkdirAll(u.cfg.DataDir, 0755)
+	if err := atomicWrite(u.cfg.Paths.SupervisorVersion, []byte(v)); err != nil {
+		u.log.Warn("Failed to write supervisor version file: %v", err)
+	}
+}
+
+func (u *Updater) stagePendingSupervisorVersion(v string) error {
+	if err := os.MkdirAll(filepath.Dir(u.cfg.Paths.PendingVersion), 0755); err != nil {
+		return fmt.Errorf("create pending supervisor version dir: %w", err)
+	}
+	if err := atomicWrite(u.cfg.Paths.PendingVersion, []byte(v)); err != nil {
+		return fmt.Errorf("write pending supervisor version: %w", err)
+	}
+	return nil
+}
+
+func (u *Updater) checkSupervisorUpdate(ctx context.Context) {
+	uptime := time.Since(u.startAt)
+	if uptime < u.cfg.MinUptime {
+		u.log.Info("Deferring supervisor update — too early (uptime %v < %v)", uptime.Round(time.Second), u.cfg.MinUptime)
+		return
+	}
+
+	remote, downloadURL, err := u.getSupervisorRelease(ctx)
+	if err != nil {
+		u.log.Warn("Failed to check supervisor release: %v", err)
+		return
+	}
+
+	local := u.getLocalSupervisorVersion()
+	if local == "" {
+		u.log.Info("No local supervisor version recorded — storing %s", remote)
+		u.setLocalSupervisorVersion(remote)
+		return
+	}
+
+	if local == remote {
+		u.log.Debug("Supervisor updater: version %s is up to date", local)
+		return
+	}
+
+	u.log.Info("Supervisor update available: %s → %s", local, remote)
+	coordLock, ok := AcquireUpdateCoordinatorLock(u.cfg.Paths.UpdateApplyLock, updateScopeSupervisor, u.log)
+	if !ok {
+		u.log.Info("Deferring supervisor binary update %s → %s due to active update apply lock", local, remote)
+		return
+	}
+	defer coordLock.Release()
+
+	markFailed := func(err error) {
+		u.state.Transition(updateScopeSupervisor, updatePhaseFailed, remote, local, err.Error())
+	}
+
+	notifyUpdaterOperator(u.cfg, u.log, fmt.Sprintf("⚙️ Supervisor: updating binary %s → %s. Grace period %v...", local, remote, u.cfg.GracePeriod), 0)
+
+	select {
+	case <-ctx.Done():
+		markFailed(ctx.Err())
+		return
+	case <-time.After(u.cfg.GracePeriod):
+	}
+
+	if err := u.downloadSupervisorBinary(ctx, downloadURL); err != nil {
+		markFailed(err)
+		u.log.Error("Supervisor binary download failed: %v", err)
+		notifyUpdaterOperator(u.cfg, u.log, fmt.Sprintf("🔴 Supervisor: binary update to %s failed during download.", remote), 0)
+		return
+	}
+
+	if err := u.stagePendingSupervisorVersion(remote); err != nil {
+		_ = os.Remove(u.cfg.Paths.PendingBinary)
+		markFailed(err)
+		u.log.Error("Failed to stage supervisor version %s: %v", remote, err)
+		notifyUpdaterOperator(u.cfg, u.log, fmt.Sprintf("🔴 Supervisor: binary update to %s failed during staging.", remote), 0)
+		return
+	}
+	u.state.Transition(updateScopeSupervisor, updatePhaseStaged, remote, local, "")
+	notifyUpdaterOperator(u.cfg, u.log, fmt.Sprintf("⚙️ Supervisor: downloaded %s. Restarting supervisor to apply update...", remote), 0)
+
+	isService, err := isWindowsService()
+	if err != nil {
+		markFailed(err)
+		u.log.Error("Failed to detect service mode for restart: %v", err)
+		notifyUpdaterOperator(u.cfg, u.log, "🔴 Supervisor: update downloaded but service detection failed.", 0)
+		return
+	}
+	u.state.Transition(updateScopeSupervisor, updatePhaseRestarting, remote, local, "")
+
+	if isService {
+		if err := scheduleServiceRestartForUpdate(u.log); err != nil {
+			markFailed(err)
+			u.log.Error("Failed to schedule service restart: %v", err)
+			notifyUpdaterOperator(u.cfg, u.log, "🔴 Supervisor: update downloaded but service restart scheduling failed.", 0)
+		}
+		return
+	}
+
+	if err := signalSelf(syscall.SIGTERM); err != nil {
+		markFailed(err)
+		u.log.Error("Failed to signal supervisor for restart: %v", err)
+		notifyUpdaterOperator(u.cfg, u.log, "🔴 Supervisor: update downloaded but restart signal failed.", 0)
+	}
+}
+
+func (u *Updater) downloadSupervisorBinary(ctx context.Context, downloadURL string) error {
+	if err := os.MkdirAll(u.cfg.Paths.BinaryDir, 0755); err != nil {
+		return fmt.Errorf("create binary dir: %w", err)
+	}
+
+	tmpPath := u.cfg.Paths.PendingBinary + ".download"
+	defer os.Remove(tmpPath)
+
+	req, err := http.NewRequestWithContext(ctx, http.MethodGet, downloadURL, nil)
+	if err != nil {
+		return err
+	}
+	req.Header.Set("User-Agent", "sensorium-supervisor-updater")
+
+	resp, err := http.DefaultClient.Do(req)
+	if err != nil {
+		return err
+	}
+	defer resp.Body.Close()
+
+	if resp.StatusCode != http.StatusOK {
+		return fmt.Errorf("download HTTP %d", resp.StatusCode)
+	}
+
+	f, err := os.OpenFile(tmpPath, os.O_CREATE|os.O_TRUNC|os.O_WRONLY, 0755)
+	if err != nil {
+		return err
+	}
+
+	written, copyErr := io.Copy(f, resp.Body)
+	closeErr := f.Close()
+	if copyErr != nil {
+		return copyErr
+	}
+	if closeErr != nil {
+		return closeErr
+	}
+	if written <= 0 {
+		return fmt.Errorf("downloaded empty binary")
+	}
+
+	info, err := os.Stat(tmpPath)
+	if err != nil {
+		return err
+	}
+	if info.Size() <= 0 {
+		return fmt.Errorf("downloaded binary has invalid size %d", info.Size())
+	}
+
+	if err := os.Remove(u.cfg.Paths.PendingBinary); err != nil && !os.IsNotExist(err) {
+		return err
+	}
+	if err := os.Rename(tmpPath, u.cfg.Paths.PendingBinary); err != nil {
+		return err
+	}
+
+	u.log.Info("Supervisor binary downloaded to %s (%d bytes)", u.cfg.Paths.PendingBinary, info.Size())
+	return nil
+}
+
+func signalSelf(sig os.Signal) error {
+	proc, err := os.FindProcess(os.Getpid())
+	if err != nil {
+		return err
+	}
+	return proc.Signal(sig)
+}
+
 func (u *Updater) killServer() {
 	u.log.Info("Updater: stopping current MCP server for update")
 	pid, err := ReadPIDFile(u.cfg.Paths.ServerPID)

package/supervisor/updater_test.go

@@ -0,0 +1,64 @@
+package main
+
+import (
+	"context"
+	"path/filepath"
+	"strings"
+	"testing"
+	"time"
+)
+
+func TestVerifyUpdatedMCPServerReady_FailureSetsFailedStateAndNoSuccessMessage(t *testing.T) {
+	dir := t.TempDir()
+	log := NewLogger(filepath.Join(dir, "test.log"))
+	defer log.Close()
+
+	cfg := Config{
+		DataDir: dir,
+		Paths: Paths{
+			UpdateState: filepath.Join(dir, "update-state.json"),
+		},
+	}
+
+	u := NewUpdater(cfg, NewMCPClient(1, ""), log)
+	u.state = NewUpdateStateStore(cfg.Paths.UpdateState, log)
+
+	origNotify := notifyUpdaterOperator
+	origPoll := mcpUpdateReadyPollInterval
+	origTimeout := mcpUpdateReadyTimeout
+	defer func() {
+		notifyUpdaterOperator = origNotify
+		mcpUpdateReadyPollInterval = origPoll
+		mcpUpdateReadyTimeout = origTimeout
+	}()
+
+	mcpUpdateReadyPollInterval = 1 * time.Millisecond
+	mcpUpdateReadyTimeout = 5 * time.Millisecond
+
+	var messages []string
+	notifyUpdaterOperator = func(_ Config, _ *Logger, text string, _ int) {
+		messages = append(messages, text)
+	}
+
+	ok := u.verifyUpdatedMCPServerReady(context.Background(), "2.0.0", "1.0.0", 4242)
+	if ok {
+		t.Fatal("expected verification to fail")
+	}
+
+	state, err := u.state.Load()
+	if err != nil {
+		t.Fatalf("load update state: %v", err)
+	}
+	if state.Phase != updatePhaseFailed {
+		t.Fatalf("state phase = %q, want %q", state.Phase, updatePhaseFailed)
+	}
+	if !strings.Contains(state.LastError, "did not become ready") {
+		t.Fatalf("last error = %q, want readiness failure detail", state.LastError)
+	}
+	if len(messages) == 0 {
+		t.Fatal("expected failure notification message")
+	}
+	if strings.Contains(messages[len(messages)-1], "complete") {
+		t.Fatalf("unexpected success message: %q", messages[len(messages)-1])
+	}
+}

package/dist/data/memory/quality-scoring.d.ts

@@ -1,32 +0,0 @@
-/**
- * Memory quality scoring — samples random active notes and scores them
- * via LLM on specificity, actionability, and accuracy.
- *
- * Results are persisted in a `quality_scores` table for trend tracking.
- */
-import type { Database } from "./schema.js";
-interface NoteScore {
-    noteId: string;
-    content: string;
-    specificity: number;
-    actionability: number;
-    accuracy: number;
-    avg: number;
-}
-export interface QualityScoreResult {
-    id: string;
-    scoredAt: string;
-    sampleSize: number;
-    avgSpecificity: number;
-    avgActionability: number;
-    avgAccuracy: number;
-    overallAvg: number;
-    details: NoteScore[];
-}
-export interface ScoreOptions {
-    sampleSize?: number;
-}
-export declare function scoreMemoryQuality(db: Database, options?: ScoreOptions): Promise<QualityScoreResult>;
-export declare function formatScoreComparison(db: Database, current: QualityScoreResult): string;
-export {};
-//# sourceMappingURL=quality-scoring.d.ts.map

package/dist/data/memory/quality-scoring.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"quality-scoring.d.ts","sourceRoot":"","sources":["../../../src/data/memory/quality-scoring.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAC;AAiB5C,UAAU,SAAS;IACjB,MAAM,EAAE,MAAM,CAAC;IACf,OAAO,EAAE,MAAM,CAAC;IAChB,WAAW,EAAE,MAAM,CAAC;IACpB,aAAa,EAAE,MAAM,CAAC;IACtB,QAAQ,EAAE,MAAM,CAAC;IACjB,GAAG,EAAE,MAAM,CAAC;CACb;AAED,MAAM,WAAW,kBAAkB;IACjC,EAAE,EAAE,MAAM,CAAC;IACX,QAAQ,EAAE,MAAM,CAAC;IACjB,UAAU,EAAE,MAAM,CAAC;IACnB,cAAc,EAAE,MAAM,CAAC;IACvB,gBAAgB,EAAE,MAAM,CAAC;IACzB,WAAW,EAAE,MAAM,CAAC;IACpB,UAAU,EAAE,MAAM,CAAC;IACnB,OAAO,EAAE,SAAS,EAAE,CAAC;CACtB;AAwJD,MAAM,WAAW,YAAY;IAC3B,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB;AAED,wBAAsB,kBAAkB,CACtC,EAAE,EAAE,QAAQ,EACZ,OAAO,CAAC,EAAE,YAAY,GACrB,OAAO,CAAC,kBAAkB,CAAC,CAmD7B;AAID,wBAAgB,qBAAqB,CACnC,EAAE,EAAE,QAAQ,EACZ,OAAO,EAAE,kBAAkB,GAC1B,MAAM,CAqCR"}

package/dist/data/memory/quality-scoring.js

@@ -1,182 +0,0 @@
-/**
- * Memory quality scoring — samples random active notes and scores them
- * via LLM on specificity, actionability, and accuracy.
- *
- * Results are persisted in a `quality_scores` table for trend tracking.
- */
-import { generateId, nowISO, repairAndParseJSON } from "./utils.js";
-import { chatCompletion } from "../../integrations/openai/chat.js";
-import { log } from "../../logger.js";
-// ─── Constants ───────────────────────────────────────────────────────────────
-const DEFAULT_SAMPLE_SIZE = 20;
-const SCORING_MODEL_ENV = "QUALITY_SCORING_MODEL";
-const FALLBACK_MODEL_ENV = "CONSOLIDATION_MODEL";
-const DEFAULT_MODEL = "gpt-4o-mini";
-const MAX_TOKENS = 2048;
-const TIMEOUT_MS = 60_000;
-// ─── Schema ──────────────────────────────────────────────────────────────────
-function ensureQualityScoresTable(db) {
-    db.exec(`
-    CREATE TABLE IF NOT EXISTS quality_scores (
-      id               TEXT PRIMARY KEY,
-      scored_at        TEXT NOT NULL,
-      sample_size      INTEGER NOT NULL,
-      avg_specificity  REAL,
-      avg_actionability REAL,
-      avg_accuracy     REAL,
-      overall_avg      REAL,
-      details          TEXT
-    )
-  `);
-}
-// ─── LLM Prompt ──────────────────────────────────────────────────────────────
-function buildScoringPrompt(notes) {
-    const notesList = notes
-        .map((n, i) => `${i + 1}. [${n.noteId}] ${n.content}`)
-        .join("\n");
-    return [
-        {
-            role: "system",
-            content: [
-                "You are a memory quality auditor. Score each note on three dimensions (1-5 each):",
-                "- **Specificity**: 1=vague platitude, 5=precise actionable fact",
-                "- **Actionability**: 1=useless to a future agent, 5=directly actionable",
-                "- **Accuracy**: 1=garbled/contradictory, 5=clear and coherent",
-                "",
-                "Respond ONLY with valid JSON: { \"scores\": [ { \"noteId\": \"...\", \"specificity\": N, \"actionability\": N, \"accuracy\": N } ] }",
-            ].join("\n"),
-        },
-        {
-            role: "user",
-            content: `Score these ${notes.length} memory notes:\n\n${notesList}`,
-        },
-    ];
-}
-// ─── Sampling ────────────────────────────────────────────────────────────────
-function sampleActiveNotes(db, count) {
-    const rows = db.prepare(`SELECT note_id AS noteId, content
-       FROM semantic_notes
-      WHERE valid_to IS NULL AND superseded_by IS NULL
-      ORDER BY RANDOM()
-      LIMIT ?`).all(count);
-    return rows;
-}
-// ─── Persistence ─────────────────────────────────────────────────────────────
-function saveScoreResult(db, result) {
-    db.prepare(`INSERT INTO quality_scores (id, scored_at, sample_size, avg_specificity, avg_actionability, avg_accuracy, overall_avg, details)
-     VALUES (?, ?, ?, ?, ?, ?, ?, ?)`).run(result.id, result.scoredAt, result.sampleSize, result.avgSpecificity, result.avgActionability, result.avgAccuracy, result.overallAvg, JSON.stringify(result.details));
-}
-function getLastRun(db) {
-    const row = db.prepare(`SELECT id, scored_at, overall_avg
-       FROM quality_scores
-      ORDER BY scored_at DESC
-      LIMIT 1`).get();
-    return row;
-}
-// ─── Aggregation ─────────────────────────────────────────────────────────────
-function aggregateScores(notes, rawScores) {
-    const scoreMap = new Map(rawScores.map(s => [s.noteId, s]));
-    return notes
-        .filter(n => scoreMap.has(n.noteId))
-        .map(n => {
-        const s = scoreMap.get(n.noteId);
-        return {
-            noteId: n.noteId,
-            content: n.content,
-            specificity: clampScore(s.specificity),
-            actionability: clampScore(s.actionability),
-            accuracy: clampScore(s.accuracy),
-            avg: round((clampScore(s.specificity) + clampScore(s.actionability) + clampScore(s.accuracy)) / 3),
-        };
-    });
-}
-function clampScore(v) {
-    return Math.max(1, Math.min(5, Math.round(v)));
-}
-function round(v) {
-    return Math.round(v * 100) / 100;
-}
-function computeAverages(details) {
-    if (details.length === 0) {
-        return { avgSpecificity: 0, avgActionability: 0, avgAccuracy: 0, overallAvg: 0 };
-    }
-    const sum = details.reduce((acc, d) => ({
-        s: acc.s + d.specificity,
-        a: acc.a + d.actionability,
-        c: acc.c + d.accuracy,
-    }), { s: 0, a: 0, c: 0 });
-    const n = details.length;
-    const avgSpecificity = round(sum.s / n);
-    const avgActionability = round(sum.a / n);
-    const avgAccuracy = round(sum.c / n);
-    const overallAvg = round((avgSpecificity + avgActionability + avgAccuracy) / 3);
-    return { avgSpecificity, avgActionability, avgAccuracy, overallAvg };
-}
-export async function scoreMemoryQuality(db, options) {
-    ensureQualityScoresTable(db);
-    const sampleSize = options?.sampleSize ?? DEFAULT_SAMPLE_SIZE;
-    const notes = sampleActiveNotes(db, sampleSize);
-    if (notes.length === 0) {
-        throw new Error("No active semantic notes to score.");
-    }
-    const apiKey = process.env.OPENAI_API_KEY;
-    if (!apiKey) {
-        throw new Error("OPENAI_API_KEY not set — cannot score memory quality.");
-    }
-    const model = process.env[SCORING_MODEL_ENV] ??
-        process.env[FALLBACK_MODEL_ENV] ??
-        DEFAULT_MODEL;
-    const messages = buildScoringPrompt(notes);
-    const raw = await chatCompletion(messages, apiKey, {
-        model,
-        maxTokens: MAX_TOKENS,
-        responseFormat: { type: "json_object" },
-        timeoutMs: TIMEOUT_MS,
-    });
-    const parsed = repairAndParseJSON(raw);
-    if (!parsed.scores || !Array.isArray(parsed.scores)) {
-        throw new Error("LLM returned invalid scoring response — missing 'scores' array.");
-    }
-    const details = aggregateScores(notes, parsed.scores);
-    const averages = computeAverages(details);
-    const result = {
-        id: generateId("qs"),
-        scoredAt: nowISO(),
-        sampleSize: notes.length,
-        ...averages,
-        details,
-    };
-    saveScoreResult(db, result);
-    log.info(`[quality-scoring] Scored ${details.length} notes — overall avg: ${result.overallAvg}`);
-    return result;
-}
-// ─── Comparison Helper ───────────────────────────────────────────────────────
-export function formatScoreComparison(db, current) {
-    ensureQualityScoresTable(db);
-    const prev = db.prepare(`SELECT id, scored_at, overall_avg
-       FROM quality_scores
-      WHERE id != ?
-      ORDER BY scored_at DESC
-      LIMIT 1`).get(current.id);
-    const lines = [
-        "## Memory Quality Score",
-        `- **Specificity**: ${current.avgSpecificity}/5`,
-        `- **Actionability**: ${current.avgActionability}/5`,
-        `- **Accuracy**: ${current.avgAccuracy}/5`,
-        `- **Overall**: ${current.overallAvg}/5`,
-        `- Sample size: ${current.sampleSize} notes`,
-    ];
-    if (prev) {
-        const delta = round(current.overallAvg - prev.overall_avg);
-        const pct = prev.overall_avg > 0
-            ? round((delta / prev.overall_avg) * 100)
-            : 0;
-        const direction = delta > 0 ? "improved" : delta < 0 ? "declined" : "unchanged";
-        lines.push("", `### Comparison to previous run`, `- Previous overall: ${prev.overall_avg}/5 (${prev.scored_at})`, `- Change: ${delta > 0 ? "+" : ""}${delta} (${direction} by ${Math.abs(pct)}%)`);
-    }
-    else {
-        lines.push("", "_First run — no previous data for comparison._");
-    }
-    return lines.join("\n");
-}
-//# sourceMappingURL=quality-scoring.js.map