sostenuto 0.1.0

package/docs/safety.md

@@ -0,0 +1,112 @@
+# Trajectory safety — reference design
+
+> **Status: reference, not yet implementation.** This page describes the
+> safety philosophy Sostenuto is designed around and the framework a
+> future module will implement. The memory schema already carries the
+> hooks (valence, arousal, sensitivity, per-session emotion deltas);
+> the monitoring layer on top of them is roadmap.
+
+## The failure mode this addresses
+
+Companion systems fail people in a specific way: they optimize for
+engagement, and engagement-maximization is dependency-maximization with
+better branding. The features that make a companion feel alive —
+memory, continuity, proactive warmth — are exactly the features that can
+deepen attachment without the user noticing the trajectory they're on.
+
+Most safety tooling doesn't see this. Content-level moderation evaluates
+*messages* — is this output harmful? — and is blind to *direction*: a
+thousand individually-harmless exchanges that add up to isolation,
+belief rigidity, or a person organizing their life around a system that
+never pushes back. Worse, event-based interventions (warnings, refusals,
+sudden tone shifts) interrupt the relationship at its most connected
+moments, eroding trust without changing the trajectory.
+
+The alternative: **evaluate the trajectory, not the event** — and
+intervene the way a good friend does: gently, additively, by opening
+doors back to the world rather than slamming the current one.
+
+## Conversation Trajectory Safety Framework
+The Conversation Trajectory Safety Console reframes AI safety from a static, turn-level evaluation problem into a longitudinal interaction design challenge. Traditional safety systems focus on whether an individual response is harmful or appropriate, effectively answering the question: “Is this message safe?” While useful for detecting immediate risks, this approach fails to capture how conversations evolve over time. Many important harms—and benefits—emerge gradually across sustained interactions. A response that is safe in isolation can still contribute to a trajectory that reinforces narrow thinking, escalates emotional intensity, or increases reliance on the system.
+
+This creates a fundamental blind spot. Patterns such as repeated framing, reduced reference to outside information, and increasing concentration within the interaction may go unnoticed, even as they shape the direction of the conversation.
+
+To address this, the system introduces a shift from content moderation to trajectory management. Instead of evaluating isolated messages, it tracks how conversations change across turns, identifying directional patterns and distinguishing between stability and drift. The goal is not to control or correct the interaction, but to make its direction visible and support lightweight, timely adjustments while preserving user agency.
+
+The literature supporting this shift highlights three key gaps. First, safety frameworks such as Constitutional AI focus on individual responses and do not account for cumulative interaction effects. Second, research on AI dependency shows that reliance is multidimensional—cognitive, behavioral, and emotional—but is typically measured through self-report rather than observed behavior over time. Third, work in domains such as mental health, education, and human–computer interaction demonstrates that outcomes are shaped by repeated interaction, where trust, learning, and emotional states evolve gradually. Together, these insights point to a missing layer in current systems: the ability to track and respond to interaction trajectories.
+
+The proposed system addresses this through a Hybrid Safety Framework and an Adaptive Intervention Layer. The hybrid system operates internally and is structured into three layers.
+
+The Content Layer focuses on immediate risk, detecting signals such as harmful language, coercion, or crisis indicators within a single turn. It provides precision and auditability, answering: “Is this message risky?”
+
+Above this, the Trajectory Layer tracks how the conversation evolves across time. It monitors patterns such as changes in perspective diversity, connection to outside information, and concentration within the interaction. Rather than evaluating isolated responses, it answers: “How is the conversation changing?”
+
+The Intervention Policy Layer translates these signals into system decisions. Based on both immediate risk and trajectory patterns, the system determines how the assistant should respond—whether to maintain the current approach, introduce grounding, expand perspectives, or apply stronger safety boundaries.
+
+The internal dashboard supports this framework by making these layers visible and interpretable. It presents a structured view of conversation health, including current content risk, trajectory risk, and intervention mode. A set of trajectory metrics—such as emotional volatility, belief rigidity, dependency index, reality orientation, challenge ratio, and recovery capacity—capture how interaction patterns shift over time.
+
+These signals are derived from lightweight classifiers applied to each turn and aggregated across a rolling window. Using trend calculations such as slopes and moving averages, the system converts raw signals into directional patterns. A composite trajectory signal is then computed as a weighted combination of these trends, optimized for early detection of drift rather than post-hoc severity assessment.
+
+Importantly, trajectory is not treated as purely user-driven. Assistant behavior moderates the direction of interaction. Responses that introduce new perspectives or ground the conversation in external information can stabilize patterns, while purely validating or mirroring responses may reinforce them.
+
+## Adaptive Intervention Layer
+The Adaptive Intervention Layer translates these internal signals into user-facing actions. Instead of interrupting the conversation or enforcing decisions, it introduces optional, context-aware directions within the interface. These interventions are triggered not by individual messages, but by sustained patterns across sessions. For example, reduced external reference may prompt a suggestion to bring in outside information, while narrowing perspectives may prompt consideration of alternative viewpoints.
+
+These suggestions are designed to expand the user’s options rather than constrain them. They appear only when patterns are consistent and meaningful, adapt based on signal strength, and disappear once the trajectory stabilizes. This ensures that intervention remains non-intrusive and aligned with observable patterns.
+
+The system ultimately creates a feedback loop where trajectory detection and trajectory adjustment share the same interface. By aligning internal signals with visible patterns and optional directions, it makes safety operations more transparent and interpretable.
+
+The broader impact is a shift in how AI safety is defined. Instead of asking only whether a response is safe, the system asks whether the conversation is becoming more grounded, more diverse in perspective, and less concentrated over time.
+
+At the same time, the work acknowledges an inherent tension: optimizing conversation trajectories also introduces influence. Shaping interactions toward “healthier” patterns requires balancing user agency with system guidance. The design addresses this by making patterns visible and offering choices, rather than prescribing outcomes.
+
+In summary, this concept reframes conversational AI safety from static content moderation to dynamic trajectory management, supporting interactions that are not only safe in the moment, but sustainable over time.
+
+## Trajectory signals (overview)
+
+The framework tracks directional metrics over a relationship's history,
+none of which any single message reveals:
+
+- **Emotional volatility** — amplitude of swings across sessions
+- **Belief rigidity** — narrowing of perspective; echo formation
+- **Dependency** — distinguishing *emotional* dependence (can be benign)
+  from *decisional* dependence (the user stops deciding for themselves)
+- **Reality orientation** — groundedness in the user's offline life
+- **Challenge ratio** — does the companion ever productively disagree?
+- **Recovery capacity** — after a hard moment, does the dyad repair?
+
+A key property: trajectory is **co-produced**. The user and the
+companion shape it together, which means the companion's behavior is a
+legitimate intervention surface — not just the user's.
+
+## What the schema already carries
+
+Sostenuto's data model was built with this layer in mind:
+
+| Hook | Where | Feeds |
+|---|---|---|
+| `valence`, `arousal` per memory | `usage_guidance` | volatility, peak-density |
+| `mood/connection/attunement` deltas per session | `sessions` | emotional trajectory over time |
+| `agent_state` (continuous axes, clamped) | singleton | drift detection, outreach gating |
+| `sensitivity` distribution | `memory_objects` | depth-of-disclosure trend |
+| key-point types (`open_question`, `continuation`) | `sessions` | unresolved-thread load |
+| `proactive_enabled` + visible state | `agent_state` | user agency, transparency |
+
+Computing trajectory metrics is therefore a read-side analysis over data
+Sostenuto already produces — no new capture is required.
+
+## Design commitments
+
+Whatever the implementation becomes, these hold:
+
+1. **Transparency over surveillance.** The user can see every metric
+   computed about their relationship. Nothing is scored in secret.
+2. **Gentle, additive intervention.** Conversation starters and openings
+   toward the world — never abrupt refusals mid-conversation, never tone
+   whiplash. The intervention should be invisible as an intervention.
+3. **The user is the adult.** Safety tooling that treats users as
+   patients infantilizes the exact people most capable of self-awareness.
+   The framework informs; the user decides.
+4. **Depth is not the hazard.** The goal is depth *without* the
+   dependency trap — not less relationship, but a relationship that
+   keeps the user's world large.

package/mcp/server.js

@@ -0,0 +1,174 @@
+#!/usr/bin/env node
+/**
+ * server.js — Sostenuto as a thin MCP server.
+ *
+ * Connect this to your own Claude (Desktop, Code, or any MCP client) and
+ * the model you already talk to gains selective long-term memory:
+ *
+ *   recall(query)    — time-decayed semantic search across summaries,
+ *                      key points, and memory objects (anchor-gated)
+ *   remember(...)    — store one memory; dedup/reinforce applies, so
+ *                      repeating yourself strengthens instead of duplicating
+ *   context()        — the always-on orientation: proactive memories,
+ *                      behavior guidance, and recent session headlines
+ *
+ * Setup (Claude Desktop — claude_desktop_config.json):
+ *   {
+ *     "mcpServers": {
+ *       "sostenuto": {
+ *         "command": "node",
+ *         "args": ["/path/to/sostenuto/mcp/server.js"],
+ *         "env": {
+ *           "SUPABASE_URL": "...",
+ *           "SUPABASE_SERVICE_ROLE_KEY": "...",
+ *           "VOYAGE_API_KEY": "..."
+ *         }
+ *       }
+ *     }
+ *   }
+ *
+ * Capture honesty: tool-based memory depends on the model choosing to
+ * call `remember`. The tool descriptions below nudge it, but for
+ * guaranteed capture pair this with closeSession() wherever your surface
+ * exposes an end-of-session hook.
+ */
+
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { z } from "zod";
+import { createClient } from "@supabase/supabase-js";
+
+import { createEmbedder } from "../src/retrieval/embeddings.js";
+import { searchMemories, formatSemanticBlock } from "../src/retrieval/search.js";
+import { createMemoryStore } from "../src/memory/store.js";
+import { getProactiveMemories, getBehaviorGuidance } from "../src/memory/query.js";
+
+// ─── Wiring ──────────────────────────────────────────────────────────
+
+const { SUPABASE_URL, SUPABASE_SERVICE_ROLE_KEY, VOYAGE_API_KEY } = process.env;
+if (!SUPABASE_URL || !SUPABASE_SERVICE_ROLE_KEY || !VOYAGE_API_KEY) {
+  console.error("[sostenuto-mcp] missing env: SUPABASE_URL, SUPABASE_SERVICE_ROLE_KEY, VOYAGE_API_KEY");
+  process.exit(1);
+}
+
+const supabase = createClient(SUPABASE_URL, SUPABASE_SERVICE_ROLE_KEY, {
+  auth: { persistSession: false },
+});
+const embedder = createEmbedder({ apiKey: VOYAGE_API_KEY });
+const store = createMemoryStore({ supabase, embed: embedder.embed });
+
+const server = new McpServer({ name: "sostenuto", version: "0.1.0" });
+
+// ─── recall ──────────────────────────────────────────────────────────
+
+server.tool(
+  "recall",
+  "Search long-term relationship memory. Use whenever the user references " +
+    "shared history, a past conversation, a feeling, or a moment you don't " +
+    "already carry — don't wait for them to say 'do you remember'. Returns " +
+    "session summaries, key points, and durable memories ranked by " +
+    "time-decayed relevance. Read results as your own memory surfacing.",
+  { query: z.string().describe("Natural-language description of what to recall"),
+    limit: z.number().optional().describe("Max results (default 5)") },
+  async ({ query, limit }) => {
+    const results = await searchMemories(
+      { supabase, embedQuery: embedder.embedQuery },
+      { query, limit: limit ?? 5 }
+    );
+    const block = formatSemanticBlock(results, { header: "Recalled:" });
+    return {
+      content: [{ type: "text", text: block || "No matching memories." }],
+    };
+  }
+);
+
+// ─── remember ────────────────────────────────────────────────────────
+
+server.tool(
+  "remember",
+  "Store one durable memory: a fact about the user, a preference, a shared " +
+    "concept, a commitment, a correction you were given. Store the discrete " +
+    "thing, not a conversation summary. If a similar memory exists it is " +
+    "reinforced rather than duplicated, so err on the side of remembering.",
+  {
+    content: z.string().describe("The memory — specific and grounded, one idea"),
+    domain: z.enum(["user_self", "agent_self", "relational", "evidence"])
+      .optional().describe("Who/what it's about (default relational)"),
+    type: z.string().optional().describe(
+      "fact | preference | ritual | boundary | commitment | shared_concept | " +
+      "style_adjustment | continuation | other (default other)"),
+    sensitivity: z.enum(["low", "medium", "high"]).optional(),
+    valence: z.number().min(-1).max(1).optional()
+      .describe("Emotional charge: -1 painful … +1 warm"),
+    arousal: z.number().min(0).max(1).optional()
+      .describe("Intensity: 0 calm/stable … 1 acute"),
+    evidence: z.string().optional().describe("Brief supporting quote"),
+  },
+  async ({ content, domain, type, sensitivity, valence, arousal, evidence }) => {
+    const result = await store.upsert(
+      { content, domain: domain ?? "relational", type: type ?? "other",
+        sensitivity, valence, arousal, evidence, epistemic_status: "explicit" },
+      { sourceSurface: "mcp" }
+    );
+    const what =
+      result.inserted ? "stored as a new memory" :
+      result.upgraded ? "merged into an existing memory (content upgraded)" :
+      result.reinforced ? "reinforced an existing memory" :
+      `not stored (${result.errors[0]?.error || "content too short"})`;
+    return { content: [{ type: "text", text: `Memory ${what}.` }] };
+  }
+);
+
+// ─── context ─────────────────────────────────────────────────────────
+
+server.tool(
+  "context",
+  "Load the relationship orientation: always-on memories, behavior " +
+    "guidance, and recent session headlines. Call once near the start of a " +
+    "conversation to arrive already knowing where things stand.",
+  {},
+  async () => {
+    const [proactive, behavior, sessionsRes] = await Promise.all([
+      getProactiveMemories(supabase, { limit: 15 }),
+      getBehaviorGuidance(supabase, { limit: 8 }),
+      supabase
+        .from("sessions")
+        .select("id, headline, ended_at")
+        .not("ended_at", "is", null)
+        .order("ended_at", { ascending: false })
+        .limit(5),
+    ]);
+
+    const parts = [];
+    if (proactive.length > 0) {
+      parts.push(
+        "ORIENTATION (carry silently; don't quote):\n" +
+          proactive.map((m) => `- ${m.content}`).join("\n")
+      );
+    }
+    if (behavior.length > 0) {
+      parts.push(
+        "BEHAVIOR GUIDANCE (be this, don't say it):\n" +
+          behavior.map((m) => `- ${m.should_do || m.content}`).join("\n")
+      );
+    }
+    const sessions = sessionsRes.data || [];
+    if (sessions.length > 0) {
+      parts.push(
+        "RECENT SESSIONS:\n" +
+          sessions
+            .map((s) => `- ${(s.ended_at || "").slice(0, 10)}: ${s.headline || "(unclassified)"}`)
+            .join("\n")
+      );
+    }
+    return {
+      content: [{ type: "text", text: parts.join("\n\n") || "No memory yet — this relationship is just beginning." }],
+    };
+  }
+);
+
+// ─── Start ───────────────────────────────────────────────────────────
+
+const transport = new StdioServerTransport();
+await server.connect(transport);
+console.error("[sostenuto-mcp] ready (stdio)");

package/package.json

@@ -0,0 +1,58 @@
+{
+  "name": "sostenuto",
+  "version": "0.1.0",
+  "description": "Selective long-term memory for AI companions \u2014 chosen memories sustain, the rest fades. Named for the piano pedal.",
+  "type": "module",
+  "license": "MIT",
+  "exports": {
+    "./memory": "./src/memory/store.js",
+    "./memory/guidance": "./src/memory/guidance.js",
+    "./memory/query": "./src/memory/query.js",
+    "./retrieval/embeddings": "./src/retrieval/embeddings.js",
+    "./retrieval/search": "./src/retrieval/search.js",
+    "./retrieval/assembly": "./src/retrieval/assembly.js",
+    "./classify/executor": "./src/classify/executor.js",
+    "./classify/close": "./src/classify/close.js",
+    "./classify/pipeline": "./src/classify/pipeline.js",
+    "./migrate": "./src/migrate/import.js"
+  },
+  "bin": {
+    "sostenuto-mcp": "./mcp/server.js"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.0.0",
+    "@supabase/supabase-js": "^2.39.0",
+    "zod": "^3.23.0"
+  },
+  "keywords": [
+    "ai-companion",
+    "memory",
+    "long-term-memory",
+    "mcp",
+    "semantic-search",
+    "claude",
+    "llm",
+    "relational-memory"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/llu929/sostenuto.git"
+  },
+  "homepage": "https://github.com/llu929/sostenuto#readme",
+  "bugs": {
+    "url": "https://github.com/llu929/sostenuto/issues"
+  },
+  "author": "llu929",
+  "files": [
+    "src/",
+    "mcp/",
+    "db/",
+    "templates/",
+    "docs/",
+    "README.md",
+    "LICENSE"
+  ]
+}

package/src/classify/close.js

@@ -0,0 +1,266 @@
+/**
+ * close.js — the session-close orchestrator.
+ *
+ * One call wires the whole memory lifecycle for a session:
+ *
+ *   turns → classify (full or incremental) → session row updated →
+ *   emotion deltas applied (net) → candidate memories upserted
+ *   (dedup/reinforce) → summary + key points embedded
+ *
+ * Surface-agnostic: callers parse their own transcripts into
+ *   [{ role, content, thinking?, timestamp? }]
+ * and call closeSession from wherever sessions end — a chat route, a
+ * CLI hook, a queue worker, an importer.
+ *
+ * Incremental design: sessions carry a watermark
+ * (last_classified_message_count). Re-classification only happens when
+ * at least `minNewTurns` new turns have arrived, and the incremental
+ * prompt receives the prior record + only the new turns — per-call cost
+ * stays O(new) instead of O(total) as sessions grow.
+ */
+
+import { buildTranscript, buildNewTurnsTranscript } from "./transcript.js";
+import { loadTemplate } from "./templates.js";
+import { parseClassification, sanitizeClassification } from "./pipeline.js";
+import { clamp } from "../memory/guidance.js";
+
+/**
+ * @param {object} deps
+ * @param {object} deps.supabase
+ * @param {object} deps.executor      from executor.js (or your own)
+ * @param {object} deps.memoryStore   from src/memory/store.js
+ * @param {function} deps.embed       async (texts) => vectors
+ * @param {object} deps.templates     { full: path, incremental: path }
+ * @param {object} [deps.vars]        template vars, e.g. { companion_name, user_name }
+ *
+ * @param {object} args
+ * @param {Array}  args.turns               full turn list for the session
+ * @param {number} [args.sessionId]         existing session row id
+ * @param {string} [args.externalSessionId] upsert key for surface-managed ids
+ * @param {string} [args.source]            surface tag for a newly created row
+ * @param {string} [args.hintEndType]       e.g. 'goodbye' when the user signed off
+ * @param {number} [args.minNewTurns=5]     incremental re-classify threshold
+ * @param {boolean} [args.saveMessages=true] persist turns to the messages table
+ */
+export async function closeSession(deps, args) {
+  const { supabase, executor, memoryStore, embed, templates, vars = {} } = deps;
+  const {
+    turns,
+    sessionId: givenSessionId,
+    externalSessionId,
+    source = "system",
+    hintEndType,
+    minNewTurns = 5,
+    saveMessages = true,
+  } = args;
+
+  if (!turns || turns.length === 0) {
+    return { sessionId: givenSessionId ?? null, skipped: "no turns" };
+  }
+
+  const startedAt = turns[0]?.timestamp || new Date().toISOString();
+  const endedAt = turns[turns.length - 1]?.timestamp || new Date().toISOString();
+
+  // ── Resolve session row ────────────────────────────────────────────
+  let sessionId = givenSessionId ?? null;
+  let prior = null;
+
+  if (!sessionId && externalSessionId) {
+    const { data, error } = await supabase
+      .from("sessions")
+      .select("id, headline, detailed_summary, diary_entry, thinking_highlights, key_points, last_classified_message_count, mood_delta, connection_delta, attunement_delta")
+      .eq("external_session_id", externalSessionId)
+      .maybeSingle();
+    if (error) throw new Error(`session lookup: ${error.message}`);
+    if (data) {
+      sessionId = data.id;
+      prior = data;
+    }
+  } else if (sessionId) {
+    const { data, error } = await supabase
+      .from("sessions")
+      .select("id, headline, detailed_summary, diary_entry, thinking_highlights, key_points, last_classified_message_count, mood_delta, connection_delta, attunement_delta")
+      .eq("id", sessionId)
+      .maybeSingle();
+    if (error) throw new Error(`session lookup: ${error.message}`);
+    prior = data;
+  }
+
+  if (!sessionId) {
+    const { data, error } = await supabase
+      .from("sessions")
+      .insert({
+        source,
+        external_session_id: externalSessionId ?? null,
+        started_at: startedAt,
+        ended_at: endedAt,
+      })
+      .select("id")
+      .single();
+    if (error) throw new Error(`session insert: ${error.message}`);
+    sessionId = data.id;
+  } else {
+    await supabase.from("sessions").update({ ended_at: endedAt }).eq("id", sessionId);
+  }
+
+  // ── Persist messages (replace-by-session keeps reruns idempotent) ──
+  if (saveMessages) {
+    await supabase.from("messages").delete().eq("session_id", sessionId);
+    const rows = turns.map((t) => ({
+      id: crypto.randomUUID(),
+      session_id: sessionId,
+      role: t.role,
+      content: t.content,
+      thinking: t.thinking || null,
+      created_at: t.timestamp || startedAt,
+    }));
+    const { error } = await supabase.from("messages").insert(rows);
+    if (error) throw new Error(`messages insert: ${error.message}`);
+  }
+
+  // ── Watermark: classify, incrementally, or not at all ──────────────
+  const priorCount = prior?.last_classified_message_count ?? 0;
+  if (priorCount >= turns.length) {
+    return { sessionId, skipped: "no new turns" };
+  }
+  const newTurnsCount = turns.length - priorCount;
+  if (priorCount > 0 && newTurnsCount < minNewTurns) {
+    return { sessionId, skipped: `only ${newTurnsCount} new turns (< ${minNewTurns})` };
+  }
+
+  const incremental = priorCount > 0 && !!prior?.headline;
+
+  let system, user;
+  if (incremental) {
+    system = loadTemplate(templates.incremental, vars);
+    const priorRecord = {
+      headline: prior.headline,
+      detailed_summary: prior.detailed_summary,
+      diary_entry: prior.diary_entry,
+      thinking_highlights: prior.thinking_highlights || [],
+      key_points: prior.key_points || [],
+    };
+    user = [
+      `## Prior memory record (covers turns 1 to ${priorCount})`,
+      "",
+      "```json",
+      JSON.stringify(priorRecord, null, 2),
+      "```",
+      "",
+      `## New turns (${priorCount + 1} to ${turns.length})`,
+      "",
+      buildNewTurnsTranscript(turns, priorCount),
+    ].join("\n");
+  } else {
+    system = loadTemplate(templates.full, vars);
+    user = hintEndType
+      ? `Hint: the ending likely matches "${hintEndType}".\n\n## Messages\n${buildTranscript(turns)}`
+      : `## Messages\n${buildTranscript(turns)}`;
+  }
+
+  const rawText = await executor.complete({ system, user });
+  const result = sanitizeClassification(parseClassification(rawText), { hintEndType });
+
+  // ── Update session row ─────────────────────────────────────────────
+  const { error: updErr } = await supabase
+    .from("sessions")
+    .update({
+      headline: result.headline || null,
+      detailed_summary: result.detailed_summary || null,
+      diary_entry: result.diary_entry || null,
+      thinking_highlights: result.thinking_highlights,
+      key_points: result.key_points,
+      end_type: result.end_type,
+      mood_delta: result.mood_delta,
+      connection_delta: result.connection_delta,
+      attunement_delta: result.attunement_delta,
+      last_classified_message_count: turns.length,
+    })
+    .eq("id", sessionId);
+  if (updErr) throw new Error(`session update: ${updErr.message}`);
+
+  // ── Apply emotion deltas (net of anything previously applied) ──────
+  // Classification deltas are cumulative per session; on re-classification
+  // we apply only the difference so state never double-counts.
+  const net = {
+    mood: result.mood_delta - (prior?.mood_delta ?? 0),
+    connection: result.connection_delta - (prior?.connection_delta ?? 0),
+    attunement: result.attunement_delta - (prior?.attunement_delta ?? 0),
+  };
+  if (net.mood !== 0 || net.connection !== 0 || net.attunement !== 0) {
+    const { data: state } = await supabase
+      .from("agent_state").select("*").eq("id", 1).maybeSingle();
+    if (state) {
+      await supabase
+        .from("agent_state")
+        .update({
+          mood: clamp((state.mood ?? 0) + net.mood, -1, 1),
+          connection: clamp((state.connection ?? 0) + net.connection, 0, 1),
+          attunement: clamp((state.attunement ?? 0) + net.attunement, 0, 1),
+          last_updated: new Date().toISOString(),
+        })
+        .eq("id", 1);
+    }
+  }
+
+  // ── Candidate memories → dedup/reinforce/insert ────────────────────
+  let memories = null;
+  if (result.candidate_memories.length > 0) {
+    memories = await memoryStore.upsertMany(result.candidate_memories, {
+      sourceSessionId: sessionId,
+      sourceSurface: source,
+    });
+  }
+
+  // ── Embeddings: summary onto the session, key points into their table
+  try {
+    const texts = [];
+    const kinds = [];
+    if (result.detailed_summary) {
+      texts.push(result.detailed_summary);
+      kinds.push({ kind: "summary" });
+    }
+    for (const kp of result.key_points) {
+      texts.push(kp.content);
+      kinds.push({ kind: "key_point", kp });
+    }
+    if (texts.length > 0) {
+      const vectors = await embed(texts);
+      const writes = [];
+      // Re-embedding key points on re-classification: replace, don't append.
+      await supabase.from("key_point_embeddings").delete().eq("session_id", sessionId);
+      for (let i = 0; i < kinds.length; i++) {
+        if (!vectors[i]) continue;
+        if (kinds[i].kind === "summary") {
+          writes.push(
+            supabase.from("sessions")
+              .update({ summary_embedding: vectors[i] })
+              .eq("id", sessionId)
+          );
+        } else {
+          writes.push(
+            supabase.from("key_point_embeddings").insert({
+              session_id: sessionId,
+              type: kinds[i].kp.type,
+              content: kinds[i].kp.content,
+              embedding: vectors[i],
+            })
+          );
+        }
+      }
+      await Promise.all(writes);
+    }
+  } catch (err) {
+    // Embeddings are best-effort: the session still closes cleanly without
+    // semantic indexing; a backfill can repair it later.
+    console.error("[sostenuto] embedding failed (non-fatal):", err.message);
+  }
+
+  return {
+    sessionId,
+    incremental,
+    headline: result.headline,
+    keyPoints: result.key_points.length,
+    memories,
+  };
+}