squidclaw 3.0.20 → 3.0.21

package/dist/bundled/session-memory/handler.js

@@ -1,63 +1,682 @@
-import { c as resolveAgentWorkspaceDir } from "../../run-with-concurrency-FczpX8ng.js";
-import { c as resolveStateDir } from "../../paths-CSdAWKDO.js";
-import { t as createSubsystemLogger } from "../../subsystem-BaLYRf7D.js";
-import { B as resolveAgentIdFromSessionKey } from "../../workspace-TqfVSQuO.js";
-import "../../logger-oGKcCLZ5.js";
-import "../../model-selection-CHnojCCK.js";
-import "../../github-copilot-token-Cw3tAXM9.js";
-import "../../legacy-names-B0wgIP0Q.js";
-import "../../thinking-B-A99X3F.js";
-import "../../tokens-D2XhLqIz.js";
-import "../../pi-embedded-B_4NAHxA.js";
-import "../../plugins-AqsVZZk3.js";
-import "../../accounts-B6F_XCgS.js";
-import "../../send-B9H0BkfO.js";
-import "../../send-DtHQ7_6Z.js";
-import "../../deliver-BcnsjbAB.js";
-import "../../diagnostic-C2lklhkn.js";
-import "../../accounts-s5e9zidf.js";
-import "../../image-ops-BoN1E_WZ.js";
-import "../../send-D5D0ZGht.js";
-import "../../pi-model-discovery-o-WX5w2t.js";
-import { dt as hasInterSessionUserProvenance } from "../../pi-embedded-helpers-DQ7IaeOi.js";
-import "../../chrome-Dxm25ptH.js";
-import "../../frontmatter-CjKtFduT.js";
-import "../../skills-B9N2bqKU.js";
-import "../../path-alias-guards-Cpsiv2KL.js";
-import "../../redact-NmPEVjIo.js";
-import "../../errors-DfgAh2Ml.js";
-import { c as writeFileWithinRoot } from "../../fs-safe-CwHbZdFH.js";
-import "../../proxy-env-DXXfs2WL.js";
-import "../../store-CvQ41zCV.js";
-import "../../accounts-Bkb-J8V6.js";
-import "../../paths-CXClY8zC.js";
-import "../../tool-images-Zn6jVmkX.js";
-import "../../image-C-8Kd2Mh.js";
-import "../../audio-transcription-runner-B3u2x_ja.js";
-import "../../fetch-b8tSR7_e.js";
-import "../../fetch-guard-D16tjNsZ.js";
-import "../../api-key-rotation-TRwuCWbu.js";
-import "../../proxy-fetch-C2v-Utgg.js";
-import "../../ir-Dut0zXyS.js";
+import { a as resolveAgentDir, c as resolveAgentWorkspaceDir, l as resolveDefaultAgentId, o as resolveAgentEffectiveModelPrimary } from "../../run-with-concurrency-BFR3ReeF.js";
+import { c as resolveStateDir } from "../../paths-DA5srn0U.js";
+import { t as createSubsystemLogger } from "../../subsystem-6v7sWnAD.js";
+import { B as resolveAgentIdFromSessionKey } from "../../workspace-kVMIaBrV.js";
+import "../../logger-CnTSBL7T.js";
+import { br as DEFAULT_MODEL, l as parseModelRef, xr as DEFAULT_PROVIDER } from "../../model-selection-DuNLFQPR.js";
+import "../../github-copilot-token-B5cPlwaz.js";
+import "../../legacy-names-aGJJuzM_.js";
+import "../../thinking-B75CXkTT.js";
+import "../../tokens-DfbMVF9y.js";
+import { t as runEmbeddedPiAgent } from "../../pi-embedded-BiC4tIJ8.js";
+import "../../plugins-DvejjZnJ.js";
+import "../../accounts-DwGoZKGm.js";
+import "../../send-DdBbRpTP.js";
+import "../../send-BTUU1jWM.js";
+import "../../deliver-DMTUTpTM.js";
+import "../../diagnostic-CnVwZNbm.js";
+import "../../accounts-C7pGQPcS.js";
+import "../../image-ops-Dg8iraUV.js";
+import "../../send-BGlcHjUD.js";
+import "../../pi-model-discovery-V-InbjOM.js";
+import { dt as hasInterSessionUserProvenance } from "../../pi-embedded-helpers-Di58J7Eh.js";
+import "../../chrome-OgCChbC_.js";
+import "../../frontmatter-Cq1TcIQ2.js";
+import "../../skills-CdCS1HeL.js";
+import "../../path-alias-guards-DORgbZ1w.js";
+import "../../redact-DvzicBMu.js";
+import "../../errors-kkRuS2Cs.js";
+import { c as writeFileWithinRoot } from "../../fs-safe-BoB4X3GD.js";
+import "../../proxy-env-D-fike7s.js";
+import "../../store-D9z0dn7D.js";
+import "../../accounts-DjhBQg_8.js";
+import "../../paths-DSd911Oe.js";
+import "../../tool-images-Dp5OiXeA.js";
+import "../../image-kKMG59st.js";
+import "../../audio-transcription-runner-Cv0Q47cM.js";
+import "../../fetch-DP-JjB6Z.js";
+import "../../fetch-guard-BDy975wP.js";
+import "../../api-key-rotation-DVyYtQxC.js";
+import "../../proxy-fetch-lH6RsRTE.js";
+import "../../ir-CKK03mBV.js";
 import "../../render-DW7AcFdD.js";
-import "../../target-errors-D0ZJUbbf.js";
-import "../../commands-registry-B44COZFz.js";
-import "../../skill-commands-BwTLQRR8.js";
+import "../../target-errors-DgNRx3Nr.js";
+import "../../commands-registry-BJjv8_oR.js";
+import "../../skill-commands-Cz45_nme.js";
 import "../../fetch-tZXOZ9FV.js";
-import "../../channel-activity-CxJbx4sD.js";
-import "../../tables-BRYYxYs7.js";
-import "../../send-B5QEmMJ4.js";
-import "../../outbound-attachment-rlW7G5df.js";
-import "../../send-Bx9CqcZr.js";
+import "../../channel-activity-CPpt4XaL.js";
+import "../../tables-BTFiZyRU.js";
+import "../../send-dTQd-IyJ.js";
+import "../../outbound-attachment-DwupUxYF.js";
+import "../../send-4nRsZJXH.js";
 import "../../proxy-CecQTx_Z.js";
-import "../../manager-BPGhs30n.js";
-import "../../query-expansion-DlQOkf-g.js";
+import "../../manager-DINhLnMi.js";
+import "../../query-expansion-Dzxt6kXo.js";
 import { generateSlugViaLLM } from "../../llm-slug-generator.js";
 import { t as resolveHookConfig } from "../../config-DWRgGn0l.js";
 import fs from "node:fs/promises";
 import os from "node:os";
 import path from "node:path";
+import syncFs from "node:fs";
+import { DatabaseSync } from "node:sqlite";
 
+//#region src/memory/long-term/schema.ts
+/**
+* Long-Term Memory — SQLite Schema
+* All tables + FTS5 virtual tables + sync triggers
+*/
+const LONG_TERM_MEMORY_SCHEMA = `
+PRAGMA journal_mode = WAL;
+PRAGMA foreign_keys = ON;
+
+-- ── Working Memory (Layer 0) ─────────────────────────────────────────────────
+CREATE TABLE IF NOT EXISTS working_memory (
+  id         INTEGER PRIMARY KEY AUTOINCREMENT,
+  session_id TEXT NOT NULL,
+  agent_id   TEXT NOT NULL,
+  user_id    TEXT NOT NULL,
+  content    TEXT NOT NULL,
+  layer_hint TEXT,
+  created_at INTEGER NOT NULL DEFAULT (unixepoch())
+);
+CREATE INDEX IF NOT EXISTS idx_wm_session ON working_memory(session_id);
+CREATE INDEX IF NOT EXISTS idx_wm_agent   ON working_memory(agent_id, user_id);
+
+-- ── Episodic Memory (Layer 1) ─────────────────────────────────────────────────
+CREATE TABLE IF NOT EXISTS episodic (
+  id         INTEGER PRIMARY KEY AUTOINCREMENT,
+  agent_id   TEXT NOT NULL,
+  user_id    TEXT NOT NULL,
+  session_id TEXT,
+  timestamp  INTEGER NOT NULL,
+  summary    TEXT NOT NULL,
+  entities   TEXT,           -- JSON array (sorted), e.g. '["Preplix","Tamer"]'
+  tags       TEXT,           -- JSON array (sorted)
+  importance INTEGER NOT NULL DEFAULT 5,
+  embedding  BLOB
+);
+CREATE INDEX IF NOT EXISTS idx_ep_time   ON episodic(timestamp DESC);
+CREATE INDEX IF NOT EXISTS idx_ep_imp    ON episodic(importance DESC);
+CREATE INDEX IF NOT EXISTS idx_ep_agent  ON episodic(agent_id, user_id);
+
+-- FTS5 index for episodic — content= mode (does NOT auto-sync; triggers required)
+CREATE VIRTUAL TABLE IF NOT EXISTS episodic_fts USING fts5(
+  summary, entities, tags,
+  content=episodic,
+  content_rowid=id
+);
+
+-- CRITICAL: content= mode does NOT auto-sync. Triggers keep FTS populated.
+CREATE TRIGGER IF NOT EXISTS episodic_ai AFTER INSERT ON episodic BEGIN
+  INSERT INTO episodic_fts(rowid, summary, entities, tags)
+  VALUES (new.id, new.summary, new.entities, new.tags);
+END;
+CREATE TRIGGER IF NOT EXISTS episodic_ad AFTER DELETE ON episodic BEGIN
+  INSERT INTO episodic_fts(episodic_fts, rowid, summary, entities, tags)
+  VALUES ('delete', old.id, old.summary, old.entities, old.tags);
+END;
+CREATE TRIGGER IF NOT EXISTS episodic_au AFTER UPDATE ON episodic BEGIN
+  INSERT INTO episodic_fts(episodic_fts, rowid, summary, entities, tags)
+  VALUES ('delete', old.id, old.summary, old.entities, old.tags);
+  INSERT INTO episodic_fts(rowid, summary, entities, tags)
+  VALUES (new.id, new.summary, new.entities, new.tags);
+END;
+
+-- ── Semantic Memory (Layer 2) ─────────────────────────────────────────────────
+CREATE TABLE IF NOT EXISTS semantic (
+  id         INTEGER PRIMARY KEY AUTOINCREMENT,
+  agent_id   TEXT NOT NULL,
+  user_id    TEXT NOT NULL,
+  fact       TEXT NOT NULL,
+  subject    TEXT,
+  category   TEXT,
+  confidence REAL NOT NULL DEFAULT 1.0,
+  source     TEXT,
+  created_at INTEGER NOT NULL DEFAULT (unixepoch()),
+  updated_at INTEGER NOT NULL DEFAULT (unixepoch()),
+  active     INTEGER NOT NULL DEFAULT 1,
+  embedding  BLOB
+);
+CREATE INDEX IF NOT EXISTS idx_sem_active  ON semantic(active);
+CREATE INDEX IF NOT EXISTS idx_sem_conf    ON semantic(confidence DESC);
+CREATE INDEX IF NOT EXISTS idx_sem_agent   ON semantic(agent_id, user_id);
+CREATE INDEX IF NOT EXISTS idx_sem_subject ON semantic(subject);
+
+-- FTS5 index for semantic
+CREATE VIRTUAL TABLE IF NOT EXISTS semantic_fts USING fts5(
+  fact, subject, category,
+  content=semantic,
+  content_rowid=id
+);
+CREATE TRIGGER IF NOT EXISTS semantic_ai AFTER INSERT ON semantic BEGIN
+  INSERT INTO semantic_fts(rowid, fact, subject, category)
+  VALUES (new.id, new.fact, new.subject, new.category);
+END;
+CREATE TRIGGER IF NOT EXISTS semantic_ad AFTER DELETE ON semantic BEGIN
+  INSERT INTO semantic_fts(semantic_fts, rowid, fact, subject, category)
+  VALUES ('delete', old.id, old.fact, old.subject, old.category);
+END;
+CREATE TRIGGER IF NOT EXISTS semantic_au AFTER UPDATE ON semantic BEGIN
+  INSERT INTO semantic_fts(semantic_fts, rowid, fact, subject, category)
+  VALUES ('delete', old.id, old.fact, old.subject, old.category);
+  INSERT INTO semantic_fts(rowid, fact, subject, category)
+  VALUES (new.id, new.fact, new.subject, new.category);
+END;
+
+-- ── Procedural Memory (Layer 3) ──────────────────────────────────────────────
+CREATE TABLE IF NOT EXISTS procedural (
+  id          INTEGER PRIMARY KEY AUTOINCREMENT,
+  agent_id    TEXT NOT NULL,
+  user_id     TEXT NOT NULL,
+  name        TEXT NOT NULL,
+  description TEXT,
+  steps       TEXT NOT NULL,  -- JSON array of strings
+  tags        TEXT,           -- JSON array (sorted)
+  version     INTEGER NOT NULL DEFAULT 1,
+  active      INTEGER NOT NULL DEFAULT 1,
+  used_count  INTEGER NOT NULL DEFAULT 0,
+  last_used   INTEGER,
+  embedding   BLOB
+);
+CREATE INDEX IF NOT EXISTS idx_proc_name   ON procedural(name);
+CREATE INDEX IF NOT EXISTS idx_proc_active ON procedural(active);
+CREATE INDEX IF NOT EXISTS idx_proc_agent  ON procedural(agent_id, user_id);
+
+-- FTS5 index for procedural
+CREATE VIRTUAL TABLE IF NOT EXISTS procedural_fts USING fts5(
+  name, description, steps, tags,
+  content=procedural,
+  content_rowid=id
+);
+CREATE TRIGGER IF NOT EXISTS procedural_ai AFTER INSERT ON procedural BEGIN
+  INSERT INTO procedural_fts(rowid, name, description, steps, tags)
+  VALUES (new.id, new.name, new.description, new.steps, new.tags);
+END;
+CREATE TRIGGER IF NOT EXISTS procedural_ad AFTER DELETE ON procedural BEGIN
+  INSERT INTO procedural_fts(procedural_fts, rowid, name, description, steps, tags)
+  VALUES ('delete', old.id, old.name, old.description, old.steps, old.tags);
+END;
+CREATE TRIGGER IF NOT EXISTS procedural_au AFTER UPDATE ON procedural BEGIN
+  INSERT INTO procedural_fts(procedural_fts, rowid, name, description, steps, tags)
+  VALUES ('delete', old.id, old.name, old.description, old.steps, old.tags);
+  INSERT INTO procedural_fts(rowid, name, description, steps, tags)
+  VALUES (new.id, new.name, new.description, new.steps, new.tags);
+END;
+
+-- ── Entity Relations ─────────────────────────────────────────────────────────
+CREATE TABLE IF NOT EXISTS entity_relations (
+  id           INTEGER PRIMARY KEY AUTOINCREMENT,
+  agent_id     TEXT NOT NULL,
+  user_id      TEXT NOT NULL,
+  entity_a     TEXT NOT NULL,
+  relation     TEXT NOT NULL,
+  entity_b     TEXT NOT NULL,
+  confidence   REAL NOT NULL DEFAULT 1.0,
+  source_layer TEXT NOT NULL,
+  source_id    INTEGER NOT NULL,
+  created_at   INTEGER NOT NULL DEFAULT (unixepoch())
+);
+CREATE INDEX IF NOT EXISTS idx_er_agent    ON entity_relations(agent_id, user_id);
+CREATE INDEX IF NOT EXISTS idx_er_entity_a ON entity_relations(entity_a);
+CREATE INDEX IF NOT EXISTS idx_er_entity_b ON entity_relations(entity_b);
+
+-- ── Extraction Log ────────────────────────────────────────────────────────────
+CREATE TABLE IF NOT EXISTS extraction_log (
+  id            INTEGER PRIMARY KEY AUTOINCREMENT,
+  agent_id      TEXT NOT NULL,
+  user_id       TEXT NOT NULL,
+  session_id    TEXT NOT NULL,
+  run_at        INTEGER NOT NULL DEFAULT (unixepoch()),
+  trigger       TEXT NOT NULL,
+  items_created INTEGER NOT NULL DEFAULT 0,
+  items_updated INTEGER NOT NULL DEFAULT 0,
+  items_skipped INTEGER NOT NULL DEFAULT 0,
+  duration_ms   INTEGER
+);
+`;
+
+//#endregion
+//#region src/memory/long-term/manager.ts
+/**
+* Long-Term Memory — MemoryManager
+* CRUD operations for all 4 layers + FTS5 search
+*/
+function safeParse(json, fallback) {
+	if (!json) return fallback;
+	try {
+		return JSON.parse(json);
+	} catch {
+		return fallback;
+	}
+}
+function sanitizeFts(text) {
+	return "\"" + text.replace(/"/g, "\"\"") + "\"";
+}
+var MemoryManager = class {
+	constructor(params) {
+		this.agentId = params.agentId;
+		this.userId = params.userId;
+		const dir = path.dirname(params.dbPath);
+		if (!syncFs.existsSync(dir)) syncFs.mkdirSync(dir, { recursive: true });
+		this.db = new DatabaseSync(params.dbPath);
+		this.initSchema();
+	}
+	initSchema() {
+		this.db.exec(LONG_TERM_MEMORY_SCHEMA);
+	}
+	close() {
+		this.db.close();
+	}
+	addWorking(params) {
+		return this.db.prepare(`INSERT INTO working_memory (session_id, agent_id, user_id, content, layer_hint, created_at)
+       VALUES (?, ?, ?, ?, ?, ?)`).run(params.sessionId, this.agentId, this.userId, params.content, params.layerHint ?? null, Date.now()).lastInsertRowid;
+	}
+	getWorkingMemory(sessionId) {
+		return this.db.prepare(`SELECT * FROM working_memory WHERE session_id = ? AND agent_id = ? AND user_id = ? ORDER BY created_at ASC`).all(sessionId, this.agentId, this.userId);
+	}
+	clearWorkingMemory(sessionId) {
+		this.db.prepare(`DELETE FROM working_memory WHERE session_id = ? AND agent_id = ? AND user_id = ?`).run(sessionId, this.agentId, this.userId);
+	}
+	addEpisodic(mem) {
+		const sortedEntities = [...mem.entities ?? []].toSorted();
+		const sortedTags = [...mem.tags ?? []].toSorted();
+		return this.db.prepare(`INSERT INTO episodic (agent_id, user_id, session_id, timestamp, summary, entities, tags, importance)
+         VALUES (?, ?, ?, ?, ?, ?, ?, ?)`).run(this.agentId, this.userId, mem.session_id ?? null, mem.timestamp, mem.summary, JSON.stringify(sortedEntities), JSON.stringify(sortedTags), mem.importance).lastInsertRowid;
+	}
+	getRecentEpisodic(limit = 20) {
+		return this.db.prepare(`SELECT * FROM episodic WHERE agent_id = ? AND user_id = ?
+         ORDER BY timestamp DESC LIMIT ?`).all(this.agentId, this.userId, limit).map((r) => this.parseEpisodic(r));
+	}
+	parseEpisodic(row) {
+		return {
+			...row,
+			entities: safeParse(row.entities, []),
+			tags: safeParse(row.tags, []),
+			embedding: row.embedding ?? void 0
+		};
+	}
+	addSemantic(mem) {
+		const now = Date.now();
+		if (mem.subject && mem.category) {
+			const existing = this.db.prepare(`SELECT id FROM semantic WHERE agent_id = ? AND user_id = ?
+           AND subject = ? AND category = ? AND active = 1 LIMIT 1`).get(this.agentId, this.userId, mem.subject, mem.category);
+			if (existing) {
+				this.db.prepare(`UPDATE semantic SET fact = ?, confidence = ?, updated_at = ?, source = ?
+             WHERE id = ?`).run(mem.fact, mem.confidence ?? 1, now, mem.source ?? null, existing.id);
+				return existing.id;
+			}
+		}
+		return this.db.prepare(`INSERT INTO semantic (agent_id, user_id, fact, subject, category, confidence, source, created_at, updated_at, active)
+         VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, 1)`).run(this.agentId, this.userId, mem.fact, mem.subject ?? null, mem.category ?? null, mem.confidence ?? 1, mem.source ?? null, now, now).lastInsertRowid;
+	}
+	getActiveSemantic(limit = 50) {
+		return this.db.prepare(`SELECT * FROM semantic WHERE agent_id = ? AND user_id = ? AND active = 1
+         ORDER BY confidence DESC, updated_at DESC LIMIT ?`).all(this.agentId, this.userId, limit).map((r) => ({
+			...r,
+			embedding: r.embedding ?? void 0
+		}));
+	}
+	addProcedural(mem) {
+		const sortedTags = [...mem.tags ?? []].toSorted();
+		const existing = this.db.prepare(`SELECT id, version FROM procedural WHERE agent_id = ? AND user_id = ?
+         AND name = ? AND active = 1 LIMIT 1`).get(this.agentId, this.userId, mem.name);
+		if (existing) this.db.prepare(`UPDATE procedural SET active = 0 WHERE id = ?`).run(existing.id);
+		return this.db.prepare(`INSERT INTO procedural (agent_id, user_id, name, description, steps, tags, version, active)
+         VALUES (?, ?, ?, ?, ?, ?, ?, 1)`).run(this.agentId, this.userId, mem.name, mem.description ?? null, JSON.stringify(mem.steps), JSON.stringify(sortedTags), existing ? existing.version + 1 : 1).lastInsertRowid;
+	}
+	getActiveProcedural(limit = 30) {
+		return this.db.prepare(`SELECT * FROM procedural WHERE agent_id = ? AND user_id = ? AND active = 1
+         ORDER BY used_count DESC, last_used DESC LIMIT ?`).all(this.agentId, this.userId, limit).map((r) => ({
+			...r,
+			steps: safeParse(r.steps, []),
+			tags: safeParse(r.tags, []),
+			embedding: r.embedding ?? void 0
+		}));
+	}
+	markProceduralUsed(id) {
+		this.db.prepare(`UPDATE procedural SET used_count = used_count + 1, last_used = ? WHERE id = ?`).run(Date.now(), id);
+	}
+	search(params) {
+		const layers = params.layers ?? [
+			"episodic",
+			"semantic",
+			"procedural"
+		];
+		const limit = params.limit ?? 20;
+		const results = [];
+		for (const layer of layers) {
+			const layerResults = this.ftsSearch({
+				text: params.text,
+				layer,
+				limit
+			});
+			results.push(...layerResults);
+		}
+		results.sort((a, b) => b.similarity - a.similarity);
+		if (params.budget) return this.applyBudget(results, params.budget);
+		return results.slice(0, limit);
+	}
+	ftsSearch(params) {
+		if (params.layer === "working") return [];
+		const sanitized = sanitizeFts(params.text);
+		const results = [];
+		try {
+			if (params.layer === "episodic") {
+				const rows = this.db.prepare(`SELECT b.id, b.summary, b.entities, b.tags, b.importance, b.timestamp,
+                    episodic_fts.rank AS fts_rank, ? AS _layer
+             FROM episodic_fts
+             JOIN episodic b ON b.id = episodic_fts.rowid
+             WHERE episodic_fts MATCH ?
+               AND b.agent_id = ? AND b.user_id = ?
+             ORDER BY episodic_fts.rank
+             LIMIT ?`).all(params.layer, sanitized, this.agentId, this.userId, params.limit);
+				for (const row of rows) results.push({
+					layer: "episodic",
+					id: row.id,
+					content: row.summary,
+					tags: safeParse(row.tags, []),
+					similarity: Math.min(1, Math.abs(row.fts_rank ?? 0) / 10),
+					importance: row.importance,
+					created_at: row.timestamp,
+					_layer: row._layer
+				});
+			} else if (params.layer === "semantic") {
+				const rows = this.db.prepare(`SELECT b.id, b.fact, b.subject, b.category, b.confidence, b.updated_at,
+                    semantic_fts.rank AS fts_rank, ? AS _layer
+             FROM semantic_fts
+             JOIN semantic b ON b.id = semantic_fts.rowid
+             WHERE semantic_fts MATCH ?
+               AND b.agent_id = ? AND b.user_id = ? AND b.active = 1
+             ORDER BY semantic_fts.rank
+             LIMIT ?`).all(params.layer, sanitized, this.agentId, this.userId, params.limit);
+				for (const row of rows) results.push({
+					layer: "semantic",
+					id: row.id,
+					content: row.fact,
+					subject: row.subject ?? void 0,
+					similarity: Math.min(1, Math.abs(row.fts_rank ?? 0) / 10),
+					created_at: row.updated_at,
+					_layer: row._layer
+				});
+			} else if (params.layer === "procedural") {
+				const rows = this.db.prepare(`SELECT b.id, b.name, b.description, b.steps, b.tags, b.last_used,
+                    procedural_fts.rank AS fts_rank, ? AS _layer
+             FROM procedural_fts
+             JOIN procedural b ON b.id = procedural_fts.rowid
+             WHERE procedural_fts MATCH ?
+               AND b.agent_id = ? AND b.user_id = ? AND b.active = 1
+             ORDER BY procedural_fts.rank
+             LIMIT ?`).all(params.layer, sanitized, this.agentId, this.userId, params.limit);
+				for (const row of rows) {
+					const steps = safeParse(row.steps, []);
+					results.push({
+						layer: "procedural",
+						id: row.id,
+						content: `${row.name}${row.description ? `: ${row.description}` : ""} — Steps: ${steps.slice(0, 3).join(" → ")}${steps.length > 3 ? "…" : ""}`,
+						tags: safeParse(row.tags, []),
+						similarity: Math.min(1, Math.abs(row.fts_rank ?? 0) / 10),
+						created_at: row.last_used ?? Date.now(),
+						_layer: row._layer
+					});
+				}
+			}
+		} catch {}
+		return results;
+	}
+	applyBudget(results, budgetTokens) {
+		const output = [];
+		let usedTokens = 0;
+		for (const r of results) {
+			const approxTokens = Math.ceil(r.content.length / 4);
+			if (usedTokens + approxTokens > budgetTokens) break;
+			output.push(r);
+			usedTokens += approxTokens;
+		}
+		return output;
+	}
+	getStats() {
+		return {
+			episodic: this.db.prepare(`SELECT COUNT(*) as c FROM episodic WHERE agent_id = ? AND user_id = ?`).get(this.agentId, this.userId).c,
+			semantic: this.db.prepare(`SELECT COUNT(*) as c FROM semantic WHERE agent_id = ? AND user_id = ? AND active = 1`).get(this.agentId, this.userId).c,
+			procedural: this.db.prepare(`SELECT COUNT(*) as c FROM procedural WHERE agent_id = ? AND user_id = ? AND active = 1`).get(this.agentId, this.userId).c,
+			working: this.db.prepare(`SELECT COUNT(*) as c FROM working_memory WHERE agent_id = ? AND user_id = ?`).get(this.agentId, this.userId).c
+		};
+	}
+	logExtraction(params) {
+		this.db.prepare(`INSERT INTO extraction_log (agent_id, user_id, session_id, run_at, trigger, items_created, items_updated, items_skipped, duration_ms)
+         VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`).run(this.agentId, this.userId, params.sessionId, Date.now(), params.trigger, params.itemsCreated, params.itemsUpdated, params.itemsSkipped, params.durationMs);
+	}
+};
+
+//#endregion
+//#region src/memory/long-term/runner.ts
+/**
+* Long-Term Memory — LLM Extraction Runner
+* Uses runEmbeddedPiAgent (same pattern as generateSlugViaLLM) so all
+* existing Squidclaw auth / model selection works automatically.
+*/
+const log$1 = createSubsystemLogger("long-term-memory");
+const EXTRACTION_PROMPT_SYSTEM = `You are a memory extraction assistant. Analyze the conversation and extract structured memories.
+
+Return ONLY valid JSON in this exact format (no markdown, no explanation):
+{
+  "episodic": [
+    {"summary": "what happened", "entities": ["Person","Project"], "tags": ["tag"], "importance": 7}
+  ],
+  "semantic": [
+    {"fact": "standing fact", "subject": "about what/who", "category": "preference|rule|fact|config", "confidence": 0.9}
+  ],
+  "procedural": [
+    {"name": "procedure_name", "description": "when to use", "steps": ["Step 1", "Step 2"], "tags": ["tag"]}
+  ]
+}
+
+Rules:
+- Only extract genuinely useful long-term knowledge (skip small talk, transient details)
+- Importance: 1=trivial 5=normal 8=important 10=critical
+- Confidence: 0.0=uncertain 0.5=probable 1.0=certain
+- Entities: proper nouns only (people, projects, companies, products, servers)
+- If nothing worth remembering: {"episodic":[],"semantic":[],"procedural":[]}`;
+/**
+* Run long-term memory extraction on session content.
+* Follows the same pattern as generateSlugViaLLM.
+*/
+async function runLongTermExtraction(params) {
+	let created = 0;
+	let updated = 0;
+	let skipped = 0;
+	if (!params.sessionContent.trim()) return {
+		created,
+		updated,
+		skipped
+	};
+	let tempSessionFile = null;
+	try {
+		const cfgAgentId = resolveDefaultAgentId(params.cfg);
+		const agentDir = resolveAgentDir(params.cfg, cfgAgentId);
+		const tempDir = await fs.mkdtemp(path.join(os.tmpdir(), "squidclaw-ltm-"));
+		tempSessionFile = path.join(tempDir, "session.jsonl");
+		const prompt = `Extract memories from this conversation:
+
+${params.sessionContent.slice(-6e3)}`;
+		const modelRef = resolveAgentEffectiveModelPrimary(params.cfg, cfgAgentId);
+		const parsed = modelRef ? parseModelRef(modelRef, DEFAULT_PROVIDER) : null;
+		const provider = parsed?.provider ?? DEFAULT_PROVIDER;
+		const model = parsed?.model ?? DEFAULT_MODEL;
+		let rawResponse = "";
+		await runEmbeddedPiAgent({
+			sessionId: `ltm-extract-${Date.now()}`,
+			sessionKey: "temp:ltm-extractor",
+			agentId: cfgAgentId,
+			sessionFile: tempSessionFile,
+			workspaceDir: params.workspaceDir,
+			agentDir,
+			config: params.cfg,
+			provider,
+			model,
+			trigger: "api",
+			prompt,
+			extraSystemPrompt: EXTRACTION_PROMPT_SYSTEM,
+			onAgentEvent: (evt) => {
+				if (evt.stream === "assistant" && typeof evt.data?.text === "string") rawResponse += evt.data.text;
+			}
+		});
+		if (!rawResponse.trim()) {
+			log$1.warn("LTM extraction returned empty response");
+			return {
+				created,
+				updated,
+				skipped
+			};
+		}
+		let extracted;
+		try {
+			const jsonMatch = rawResponse.replace(/^```(?:json)?\n?/m, "").replace(/\n?```$/m, "").trim().match(/\{[\s\S]*\}/);
+			extracted = jsonMatch ? JSON.parse(jsonMatch[0]) : {
+				episodic: [],
+				semantic: [],
+				procedural: []
+			};
+		} catch {
+			log$1.warn("LTM extraction JSON parse failed", { preview: rawResponse.slice(0, 100) });
+			return {
+				created,
+				updated,
+				skipped
+			};
+		}
+		const manager = new MemoryManager({
+			dbPath: params.dbPath,
+			agentId: params.agentId,
+			userId: params.userId
+		});
+		const now = Date.now();
+		for (const ep of extracted.episodic ?? []) {
+			if (!ep.summary?.trim()) {
+				skipped++;
+				continue;
+			}
+			try {
+				manager.addEpisodic({
+					session_id: params.sessionId,
+					timestamp: now,
+					summary: ep.summary,
+					entities: ep.entities ?? [],
+					tags: ep.tags ?? [],
+					importance: Math.max(1, Math.min(10, ep.importance ?? 5))
+				});
+				created++;
+			} catch {
+				skipped++;
+			}
+		}
+		for (const sem of extracted.semantic ?? []) {
+			if (!sem.fact?.trim()) {
+				skipped++;
+				continue;
+			}
+			try {
+				manager.addSemantic({
+					fact: sem.fact,
+					subject: sem.subject,
+					category: sem.category,
+					confidence: Math.max(0, Math.min(1, sem.confidence ?? 1)),
+					source: "auto-extraction"
+				});
+				created++;
+			} catch {
+				skipped++;
+			}
+		}
+		for (const proc of extracted.procedural ?? []) {
+			if (!proc.name?.trim() || !proc.steps?.length) {
+				skipped++;
+				continue;
+			}
+			try {
+				manager.addProcedural({
+					name: proc.name,
+					description: proc.description,
+					steps: proc.steps,
+					tags: proc.tags ?? []
+				});
+				created++;
+			} catch {
+				skipped++;
+			}
+		}
+		manager.logExtraction({
+			sessionId: params.sessionId,
+			trigger: "session_end",
+			itemsCreated: created,
+			itemsUpdated: updated,
+			itemsSkipped: skipped,
+			durationMs: 0
+		});
+		await syncLongTermContextFile({
+			manager,
+			workspaceDir: params.workspaceDir
+		});
+		manager.close();
+		log$1.info(`LTM extraction: +${created} created, ${updated} updated, ${skipped} skipped`);
+	} catch (err) {
+		log$1.error("LTM extraction failed", { error: String(err) });
+	} finally {
+		if (tempSessionFile) try {
+			await fs.rm(path.dirname(tempSessionFile), {
+				recursive: true,
+				force: true
+			});
+		} catch {}
+	}
+	return {
+		created,
+		updated,
+		skipped
+	};
+}
+/**
+* Write `memory/long-term-context.md` in the workspace.
+* This file is auto-loaded by Squidclaw's bootstrap file system.
+*/
+async function syncLongTermContextFile(params) {
+	const lines = [
+		"## Long-Term Memory",
+		"*Auto-generated from conversation history. Updated at session end.*",
+		""
+	];
+	const semantic = params.manager.getActiveSemantic(40);
+	if (semantic.length > 0) {
+		lines.push("### Facts & Preferences");
+		for (const s of semantic.slice(0, 25)) {
+			const subj = s.subject ? `[${s.subject}] ` : "";
+			lines.push(`- ${subj}${s.fact}`);
+		}
+		lines.push("");
+	}
+	const episodic = params.manager.getRecentEpisodic(15);
+	if (episodic.length > 0) {
+		lines.push("### Recent Events");
+		for (const e of episodic) {
+			const date = new Date(e.timestamp).toISOString().slice(0, 10);
+			lines.push(`- [${date}] ${e.summary}`);
+		}
+		lines.push("");
+	}
+	const procedural = params.manager.getActiveProcedural(10);
+	if (procedural.length > 0) {
+		lines.push("### Known Workflows");
+		for (const p of procedural.slice(0, 5)) lines.push(`- **${p.name}**: ${p.description ?? ""}`);
+		lines.push("");
+	}
+	const stats = params.manager.getStats();
+	lines.push(`*${stats.episodic} events · ${stats.semantic} facts · ${stats.procedural} workflows*`);
+	const memDir = path.join(params.workspaceDir, "memory");
+	await fs.mkdir(memDir, { recursive: true });
+	await fs.writeFile(path.join(memDir, "long-term-context.md"), lines.join("\n"), "utf-8");
+}
+
+//#endregion
 //#region src/hooks/bundled/session-memory/handler.ts
 /**
 * Session memory hook handler
@@ -227,6 +846,23 @@ const saveSessionToMemory = async (event) => {
 		log.debug("Memory file written successfully");
 		const relPath = memoryFilePath.replace(os.homedir(), "~");
 		log.info(`Session context saved to ${relPath}`);
+		if (sessionContent && cfg) {
+			const ltmAgentId = agentId ?? "default";
+			const ltmDbPath = path.join(workspaceDir, "memory", "long-term.db");
+			setImmediate(() => {
+				runLongTermExtraction({
+					sessionContent,
+					sessionId: (context.previousSessionEntry || context.sessionEntry || {}).sessionId ?? `session-${Date.now()}`,
+					cfg,
+					workspaceDir,
+					agentId: ltmAgentId,
+					userId: ltmAgentId,
+					dbPath: ltmDbPath
+				}).catch((err) => {
+					log.warn("Long-term memory extraction failed (non-fatal)", { error: String(err) });
+				});
+			});
+		}
 	} catch (err) {
 		if (err instanceof Error) log.error("Failed to save session memory", {
 			errorName: err.name,