@tekmidian/pai 0.54.1 → 0.56.0

package/dist/{postgres-CUSXWgTG.mjs → postgres-nvU5pShF.mjs}

@@ -1,4 +1,7 @@
-import { t as STOP_WORDS } from "./stop-words-BaMEGVeY.mjs";
+import { d as sha256 } from "./helpers-D9WkIf9R.mjs";
+import { t as STOP_WORDS } from "./stop-words-ClCwO8mZ.mjs";
+import { n as indexAllWithBackend } from "./async-CLvuY7b-.mjs";
+import { t as entityContentId } from "./kg-entity-Cj8Q6YmU.mjs";
 import { readFileSync } from "node:fs";
 import { dirname, join } from "node:path";
 import { fileURLToPath } from "node:url";
@@ -505,6 +508,574 @@ async function searchVaultNameIndex(pool, query, limit = 100) {
 	return (await pool.query("SELECT DISTINCT vault_path FROM vault_name_index WHERE lower(name) LIKE lower($1) LIMIT $2", [`%${query}%`, limit])).rows.map((row) => row.vault_path);
 }
 
+//#endregion
+//#region src/storage/postgres/tunnels.ts
+/**
+* Postgres implementation of cross-project concept "tunnel" detection —
+* moved from memory/tunnels.ts alongside its SQLite counterpart
+* (storage/sqlite/tunnels.ts) so raw SQL against the federation database
+* lives entirely under src/storage/.
+*
+* Uses ts_stat() + plainto_tsquery to efficiently find terms that appear
+* across multiple projects.
+*/
+async function findTunnelsForSlugMap(pool, slugMap, opts) {
+	const projectIds = Object.keys(slugMap).map(Number);
+	if (projectIds.length < 2) return {
+		tunnels: [],
+		projects_analyzed: projectIds.length,
+		total_concepts_evaluated: 0
+	};
+	let candidateTerms = (await pool.query(`SELECT word, ndoc, nentry
+     FROM ts_stat(
+       'SELECT to_tsvector(''simple'', text) FROM memory_chunks WHERE project_id = ANY($1)'
+     )
+     WHERE length(word) >= 3
+       AND nentry >= $2
+     ORDER BY ndoc DESC
+     LIMIT 500`, [projectIds, opts.min_occurrences])).rows.map((r) => r.word).filter((t) => !STOP_WORDS.has(t));
+	if (candidateTerms.length === 0) return {
+		tunnels: [],
+		projects_analyzed: projectIds.length,
+		total_concepts_evaluated: 0
+	};
+	candidateTerms = candidateTerms.slice(0, 200);
+	const valuesClause = candidateTerms.map((t, i) => `($${i + 2}::text)`).join(", ");
+	const batchResult = await pool.query(`SELECT v.concept, c.project_id::text, COUNT(*) AS cnt,
+            MIN(c.updated_at) AS first_seen,
+            MAX(c.updated_at) AS last_seen
+     FROM (VALUES ${valuesClause}) AS v(concept)
+     JOIN memory_chunks c
+       ON to_tsvector('simple', c.text) @@ plainto_tsquery('simple', v.concept)
+      AND c.project_id = ANY($1)
+     GROUP BY v.concept, c.project_id`, [projectIds, ...candidateTerms]);
+	const byConceptMap = /* @__PURE__ */ new Map();
+	for (const row of batchResult.rows) {
+		const existing = byConceptMap.get(row.concept) ?? {
+			projects: /* @__PURE__ */ new Set(),
+			occurrences: 0,
+			firstSeen: Infinity,
+			lastSeen: -Infinity
+		};
+		existing.projects.add(parseInt(row.project_id, 10));
+		existing.occurrences += parseInt(row.cnt, 10);
+		const fs = parseInt(row.first_seen, 10);
+		const ls = parseInt(row.last_seen, 10);
+		if (fs < existing.firstSeen) existing.firstSeen = fs;
+		if (ls > existing.lastSeen) existing.lastSeen = ls;
+		byConceptMap.set(row.concept, existing);
+	}
+	const tunnels = [];
+	for (const [concept, data] of byConceptMap) {
+		if (data.projects.size < opts.min_projects) continue;
+		if (data.occurrences < opts.min_occurrences) continue;
+		const projects = [...data.projects].map((id) => slugMap[id] ?? String(id)).filter(Boolean);
+		tunnels.push({
+			concept,
+			projects,
+			occurrences: data.occurrences,
+			first_seen: data.firstSeen === Infinity ? 0 : data.firstSeen,
+			last_seen: data.lastSeen === -Infinity ? 0 : data.lastSeen
+		});
+	}
+	tunnels.sort((a, b) => {
+		const byProjects = b.projects.length - a.projects.length;
+		if (byProjects !== 0) return byProjects;
+		return b.occurrences - a.occurrences;
+	});
+	return {
+		tunnels: tunnels.slice(0, opts.limit),
+		projects_analyzed: projectIds.length,
+		total_concepts_evaluated: candidateTerms.length
+	};
+}
+/** Find cross-project concept tunnels against a Postgres federation database. */
+async function findTunnelsPostgres(pool, registry, options) {
+	const opts = {
+		min_projects: options?.min_projects ?? 2,
+		min_occurrences: options?.min_occurrences ?? 3,
+		limit: options?.limit ?? 20
+	};
+	const projectRows = await registry.listProjects({ excludeArchived: true });
+	const slugMap = {};
+	for (const { id, slug } of projectRows) slugMap[id] = slug;
+	return findTunnelsForSlugMap(pool, slugMap, opts);
+}
+
+//#endregion
+//#region src/storage/postgres/sources.ts
+const num = (v) => Number(v ?? 0);
+async function getMemorySourcesReportPostgres(pool) {
+	return {
+		composition: (await pool.query(`SELECT source, tier, COUNT(*) AS chunks, COUNT(embedding) AS embedded
+       FROM pai_chunks GROUP BY source, tier ORDER BY COUNT(*) DESC`)).rows.map((r) => ({
+			source: r.source,
+			tier: r.tier,
+			chunks: num(r.chunks),
+			embedded: num(r.embedded)
+		})),
+		paths: (await pool.query(`SELECT path, COUNT(*) AS chunks FROM pai_chunks GROUP BY path`)).rows.map((r) => ({
+			path: r.path,
+			chunks: num(r.chunks)
+		})),
+		churn: (await pool.query(`SELECT to_char(to_timestamp(updated_at/1000),'YYYY-MM-DD') AS day,
+            COUNT(*) AS chunks, COUNT(embedding) AS embedded
+       FROM pai_chunks GROUP BY day ORDER BY day DESC LIMIT 10`)).rows.map((r) => ({
+			day: r.day,
+			chunks: num(r.chunks),
+			embedded: num(r.embedded)
+		}))
+	};
+}
+
+//#endregion
+//#region src/storage/postgres/kg-triples.ts
+function rowToTriple(row) {
+	return {
+		id: row.id,
+		subject: row.subject,
+		predicate: row.predicate,
+		object: row.object,
+		project_id: row.project_id,
+		source_session: row.source_session,
+		valid_from: new Date(row.valid_from),
+		valid_to: row.valid_to ? new Date(row.valid_to) : void 0,
+		confidence: row.confidence,
+		created_at: new Date(row.created_at)
+	};
+}
+async function addKgTriple(pool, params) {
+	const confidence = params.confidence ?? "EXTRACTED";
+	return rowToTriple((await pool.query(`INSERT INTO kg_triples
+       (subject, predicate, object, project_id, source_session, confidence)
+     VALUES ($1, $2, $3, $4, $5, $6)
+     RETURNING *`, [
+		params.subject,
+		params.predicate,
+		params.object,
+		params.project_id ?? null,
+		params.source_session ?? null,
+		confidence
+	])).rows[0]);
+}
+/**
+* Query triples by subject, predicate, object, and/or project.
+* Supports point-in-time queries via as_of.
+* By default only returns currently-valid triples (valid_to IS NULL).
+*/
+async function queryKgTriples(pool, params) {
+	const conditions = [];
+	const values = [];
+	let idx = 1;
+	if (params.subject !== void 0) {
+		conditions.push(`subject = $${idx++}`);
+		values.push(params.subject);
+	}
+	if (params.predicate !== void 0) {
+		conditions.push(`predicate = $${idx++}`);
+		values.push(params.predicate);
+	}
+	if (params.object !== void 0) {
+		conditions.push(`object = $${idx++}`);
+		values.push(params.object);
+	}
+	if (params.project_id !== void 0) {
+		conditions.push(`project_id = $${idx++}`);
+		values.push(params.project_id);
+	}
+	if (params.as_of !== void 0) {
+		conditions.push(`valid_from <= $${idx++}`);
+		values.push(params.as_of);
+		conditions.push(`(valid_to IS NULL OR valid_to > $${idx++})`);
+		values.push(params.as_of);
+	} else if (!params.include_invalidated) conditions.push(`valid_to IS NULL`);
+	const where = conditions.length > 0 ? `WHERE ${conditions.join(" AND ")}` : "";
+	return (await pool.query(`SELECT * FROM kg_triples ${where} ORDER BY valid_from DESC`, values)).rows.map(rowToTriple);
+}
+/** Invalidate a triple by setting valid_to = NOW(). Does not delete the row — preserves history. */
+async function invalidateKgTriple(pool, tripleId) {
+	await pool.query(`UPDATE kg_triples SET valid_to = NOW() WHERE id = $1 AND valid_to IS NULL`, [tripleId]);
+}
+/**
+* Find contradictions: cases where the same (subject, predicate) pair has
+* multiple currently-valid objects.
+*/
+async function getKgContradictions(pool, subject) {
+	return (await pool.query(`SELECT subject, predicate, array_agg(object ORDER BY object) AS objects
+     FROM kg_triples
+     WHERE subject = $1
+       AND valid_to IS NULL
+     GROUP BY subject, predicate
+     HAVING COUNT(*) > 1`, [subject])).rows.map((row) => ({
+		subject: row.subject,
+		predicate: row.predicate,
+		objects: row.objects
+	}));
+}
+async function getKgStats(pool) {
+	const totals = await pool.query(`SELECT
+       COUNT(*)::text                                            AS total,
+       COUNT(*) FILTER (WHERE valid_to IS NULL)::text            AS valid,
+       COUNT(*) FILTER (WHERE valid_to IS NOT NULL)::text        AS invalidated,
+       COUNT(DISTINCT subject)::text                             AS subjects,
+       COUNT(DISTINCT predicate)::text                           AS predicates
+     FROM kg_triples`);
+	const contradictions = await pool.query(`SELECT COUNT(*)::text AS count FROM (
+       SELECT subject, predicate
+       FROM kg_triples
+       WHERE valid_to IS NULL
+       GROUP BY subject, predicate
+       HAVING COUNT(*) > 1
+     ) c`);
+	const row = totals.rows[0];
+	return {
+		total: parseInt(row?.total ?? "0", 10),
+		valid: parseInt(row?.valid ?? "0", 10),
+		invalidated: parseInt(row?.invalidated ?? "0", 10),
+		subjects: parseInt(row?.subjects ?? "0", 10),
+		predicates: parseInt(row?.predicates ?? "0", 10),
+		contradictions: parseInt(contradictions.rows[0]?.count ?? "0", 10)
+	};
+}
+
+//#endregion
+//#region src/storage/postgres/observations.ts
+/**
+* Inlined schema DDL — avoids runtime file reads that break in bundled code
+* (the bundler puts this in a shared chunk whose __dirname differs from src/).
+*/
+const SCHEMA_SQL = `
+CREATE TABLE IF NOT EXISTS pai_observations (
+  id SERIAL PRIMARY KEY,
+  session_id TEXT NOT NULL,
+  project_id INTEGER,
+  project_slug TEXT,
+  type TEXT NOT NULL CHECK (type IN ('decision', 'bugfix', 'feature', 'refactor', 'discovery', 'change')),
+  title TEXT NOT NULL,
+  narrative TEXT,
+  tool_name TEXT,
+  tool_input_summary TEXT,
+  files_read JSONB DEFAULT '[]'::jsonb,
+  files_modified JSONB DEFAULT '[]'::jsonb,
+  concepts JSONB DEFAULT '[]'::jsonb,
+  content_hash TEXT,
+  created_at TIMESTAMPTZ DEFAULT NOW()
+);
+
+CREATE INDEX IF NOT EXISTS idx_obs_project ON pai_observations(project_id);
+CREATE INDEX IF NOT EXISTS idx_obs_session ON pai_observations(session_id);
+CREATE INDEX IF NOT EXISTS idx_obs_type ON pai_observations(type);
+CREATE INDEX IF NOT EXISTS idx_obs_created ON pai_observations(created_at DESC);
+CREATE INDEX IF NOT EXISTS idx_obs_hash ON pai_observations(content_hash);
+
+CREATE TABLE IF NOT EXISTS pai_session_summaries (
+  id SERIAL PRIMARY KEY,
+  session_id TEXT NOT NULL UNIQUE,
+  project_id INTEGER,
+  project_slug TEXT,
+  request TEXT,
+  investigated TEXT,
+  learned TEXT,
+  completed TEXT,
+  next_steps TEXT,
+  observation_count INTEGER DEFAULT 0,
+  created_at TIMESTAMPTZ DEFAULT NOW()
+);
+
+CREATE INDEX IF NOT EXISTS idx_ss_project ON pai_session_summaries(project_id);
+CREATE INDEX IF NOT EXISTS idx_ss_session ON pai_session_summaries(session_id);
+`;
+let _tablesEnsured = false;
+/**
+* Run schema DDL idempotently against the given pool.
+* Uses a module-level flag so subsequent calls are no-ops within the same
+* process lifetime (the SQL itself uses IF NOT EXISTS so it is safe to re-run).
+*/
+async function ensureObservationTables(pool) {
+	if (_tablesEnsured) return;
+	await pool.query(SCHEMA_SQL);
+	_tablesEnsured = true;
+}
+const SKILL_TELEMETRY_SCHEMA_SQL = `
+CREATE TABLE IF NOT EXISTS pai_skill_telemetry (
+  id               SERIAL PRIMARY KEY,
+  scope            TEXT NOT NULL DEFAULT 'default',
+  skill_name       TEXT NOT NULL,
+  source           TEXT NOT NULL DEFAULT 'local',
+  status           TEXT NOT NULL DEFAULT 'active' CHECK (status IN ('trial','active','archived')),
+  trigger_count    INTEGER NOT NULL DEFAULT 0,
+  accept_count     INTEGER NOT NULL DEFAULT 0,
+  first_triggered  TIMESTAMPTZ DEFAULT NOW(),
+  last_triggered   TIMESTAMPTZ DEFAULT NOW(),
+  context_projects JSONB DEFAULT '[]'::jsonb,
+  hash             TEXT,
+  audit_status     TEXT,
+  last_audited     TIMESTAMPTZ,
+  UNIQUE(scope, skill_name, source)
+);
+
+CREATE INDEX IF NOT EXISTS idx_skilltel_scope   ON pai_skill_telemetry(scope);
+CREATE INDEX IF NOT EXISTS idx_skilltel_status  ON pai_skill_telemetry(scope, status);
+CREATE INDEX IF NOT EXISTS idx_skilltel_last    ON pai_skill_telemetry(last_triggered DESC);
+`;
+let _skillTelemetryEnsured = false;
+async function ensureSkillTelemetryTable(pool) {
+	if (_skillTelemetryEnsured) return;
+	await pool.query(SKILL_TELEMETRY_SCHEMA_SQL);
+	_skillTelemetryEnsured = true;
+}
+/** Hash = SHA256(session_id + tool_name + title).slice(0, 16) */
+function computeContentHash(sessionId, toolName, title) {
+	return sha256(sessionId + "\0" + toolName + "\0" + title).slice(0, 16);
+}
+/**
+* Insert an observation, skipping duplicates within a 30-second window.
+* Returns the inserted row's id, or null if the insert was suppressed.
+*/
+async function storeObservation(pool, obs) {
+	await ensureObservationTables(pool);
+	const hash = computeContentHash(obs.session_id, obs.tool_name, obs.title);
+	const dupCheck = await pool.query(`SELECT id FROM pai_observations
+     WHERE content_hash = $1
+       AND session_id   = $2
+       AND created_at  >= NOW() - INTERVAL '30 seconds'
+     LIMIT 1`, [hash, obs.session_id]);
+	if (dupCheck.rowCount && dupCheck.rowCount > 0) return null;
+	return (await pool.query(`INSERT INTO pai_observations
+       (session_id, project_id, project_slug, type, title, narrative,
+        tool_name, tool_input_summary, files_read, files_modified, concepts, content_hash)
+     VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9::jsonb, $10::jsonb, $11::jsonb, $12)
+     RETURNING id`, [
+		obs.session_id,
+		obs.project_id ?? null,
+		obs.project_slug ?? null,
+		obs.type,
+		obs.title,
+		obs.narrative ?? null,
+		obs.tool_name,
+		obs.tool_input_summary ?? null,
+		JSON.stringify(obs.files_read),
+		JSON.stringify(obs.files_modified),
+		JSON.stringify(obs.concepts),
+		hash
+	])).rows[0]?.id ?? null;
+}
+/**
+* Attribute an observation to the active project covering `cwd`, then store
+* it. One shared sequence for every writer (IPC handler, cache keepalive) so
+* the lookup query exists exactly once.
+*/
+async function storeObservationWithProject(pool, registry, obs) {
+	let project_id = null;
+	let project_slug = null;
+	if (obs.cwd) {
+		const row = await registry.findProjectByCwdPrefix(obs.cwd);
+		if (row) {
+			project_id = row.id;
+			project_slug = row.slug;
+		}
+	}
+	return storeObservation(pool, {
+		...obs,
+		project_id,
+		project_slug
+	});
+}
+async function queryObservations(pool, opts = {}) {
+	await ensureObservationTables(pool);
+	const conditions = [];
+	const params = [];
+	let idx = 1;
+	if (opts.projectId !== void 0) {
+		conditions.push(`project_id = $${idx++}`);
+		params.push(opts.projectId);
+	}
+	if (opts.sessionId !== void 0) {
+		conditions.push(`session_id = $${idx++}`);
+		params.push(opts.sessionId);
+	}
+	if (opts.type !== void 0) {
+		conditions.push(`type = $${idx++}`);
+		params.push(opts.type);
+	}
+	const where = conditions.length > 0 ? `WHERE ${conditions.join(" AND ")}` : "";
+	const limit = opts.limit ?? 50;
+	const offset = opts.offset ?? 0;
+	params.push(limit, offset);
+	return (await pool.query(`SELECT id, session_id, project_id, project_slug, type, title, narrative,
+            tool_name, tool_input_summary,
+            files_read, files_modified, concepts,
+            content_hash, created_at
+     FROM pai_observations
+     ${where}
+     ORDER BY created_at DESC
+     LIMIT $${idx++} OFFSET $${idx}`, params)).rows;
+}
+async function queryRecentObservations(pool, projectId, limit) {
+	await ensureObservationTables(pool);
+	return (await pool.query(`SELECT id, session_id, project_id, project_slug, type, title, narrative,
+            tool_name, tool_input_summary,
+            files_read, files_modified, concepts,
+            content_hash, created_at
+     FROM pai_observations
+     WHERE project_id = $1
+     ORDER BY created_at DESC
+     LIMIT $2`, [projectId, limit])).rows;
+}
+async function querySessionObservations(pool, sessionId) {
+	await ensureObservationTables(pool);
+	return (await pool.query(`SELECT id, session_id, project_id, project_slug, type, title, narrative,
+            tool_name, tool_input_summary,
+            files_read, files_modified, concepts,
+            content_hash, created_at
+     FROM pai_observations
+     WHERE session_id = $1
+     ORDER BY created_at ASC`, [sessionId])).rows;
+}
+async function getObservationStats(pool) {
+	await ensureObservationTables(pool);
+	const [totalRes, byTypeRes, byProjectRes, recentRes] = await Promise.all([
+		pool.query("SELECT COUNT(*) as count FROM pai_observations"),
+		pool.query("SELECT type, COUNT(*) as count FROM pai_observations GROUP BY type ORDER BY count DESC"),
+		pool.query("SELECT project_slug, COUNT(*) as count FROM pai_observations GROUP BY project_slug ORDER BY count DESC LIMIT 15"),
+		pool.query("SELECT created_at FROM pai_observations ORDER BY created_at DESC LIMIT 1")
+	]);
+	return {
+		total: parseInt(totalRes.rows[0]?.count ?? "0", 10),
+		by_type: byTypeRes.rows.map((r) => ({
+			type: r.type,
+			count: parseInt(r.count, 10)
+		})),
+		by_project: byProjectRes.rows.map((r) => ({
+			project_slug: r.project_slug,
+			count: parseInt(r.count, 10)
+		})),
+		most_recent: recentRes.rows[0]?.created_at ?? null
+	};
+}
+/**
+* Observation-type counts per vault path, for the graph_* handlers (note
+* enrichment). Falls back to an empty map when the query fails — this is
+* best-effort enrichment, never a hard dependency for graph responses.
+*/
+async function getObservationTypesForPaths(pool, filePaths, projectId) {
+	if (filePaths.length === 0) return /* @__PURE__ */ new Map();
+	try {
+		const params = [filePaths];
+		let projectFilter = "";
+		if (projectId !== void 0) {
+			params.push(projectId);
+			projectFilter = `AND project_id = $${params.length}`;
+		}
+		const result = await pool.query(`SELECT unnested_path AS path, type, COUNT(*) AS cnt
+       FROM pai_observations,
+            LATERAL unnest(files_modified || files_read) AS unnested_path
+       WHERE unnested_path = ANY($1::text[])
+         ${projectFilter}
+       GROUP BY unnested_path, type`, params);
+		const byPath = /* @__PURE__ */ new Map();
+		for (const row of result.rows) {
+			const existing = byPath.get(row.path) ?? {};
+			existing[row.type] = (existing[row.type] ?? 0) + parseInt(row.cnt, 10);
+			byPath.set(row.path, existing);
+		}
+		return byPath;
+	} catch {
+		return /* @__PURE__ */ new Map();
+	}
+}
+/** Upsert a session summary. Uses ON CONFLICT on session_id so re-calling with updated content is safe. */
+async function storeSessionSummary(pool, summary) {
+	await ensureObservationTables(pool);
+	await pool.query(`INSERT INTO pai_session_summaries
+       (session_id, project_id, project_slug, request, investigated,
+        learned, completed, next_steps, observation_count)
+     VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9)
+     ON CONFLICT (session_id) DO UPDATE SET
+       project_id        = EXCLUDED.project_id,
+       project_slug      = EXCLUDED.project_slug,
+       request           = EXCLUDED.request,
+       investigated      = EXCLUDED.investigated,
+       learned           = EXCLUDED.learned,
+       completed         = EXCLUDED.completed,
+       next_steps        = EXCLUDED.next_steps,
+       observation_count = EXCLUDED.observation_count`, [
+		summary.session_id,
+		summary.project_id ?? null,
+		summary.project_slug ?? null,
+		summary.request ?? null,
+		summary.investigated ?? null,
+		summary.learned ?? null,
+		summary.completed ?? null,
+		summary.next_steps ?? null,
+		summary.observation_count ?? 0
+	]);
+}
+async function queryRecentSummaries(pool, projectId, limit) {
+	await ensureObservationTables(pool);
+	return (await pool.query(`SELECT id, session_id, project_id, project_slug,
+            request, investigated, learned, completed, next_steps,
+            observation_count, created_at
+     FROM pai_session_summaries
+     WHERE project_id = $1
+     ORDER BY created_at DESC
+     LIMIT $2`, [projectId, limit])).rows;
+}
+/**
+* Record a single skill invocation. Upserts on (scope, skill_name, source):
+* increments trigger_count, refreshes last_triggered, and dedup-merges the
+* project slug into context_projects.
+*/
+async function recordSkillInvocation(pool, input) {
+	await ensureSkillTelemetryTable(pool);
+	const scope = input.scope ?? "default";
+	const source = input.source ?? "local";
+	const proj = input.project_slug ?? null;
+	const initialProjects = JSON.stringify(proj ? [proj] : []);
+	await pool.query(`INSERT INTO pai_skill_telemetry
+       (scope, skill_name, source, trigger_count, context_projects)
+     VALUES ($1, $2, $3, 1, $4::jsonb)
+     ON CONFLICT (scope, skill_name, source) DO UPDATE SET
+       trigger_count    = pai_skill_telemetry.trigger_count + 1,
+       last_triggered   = NOW(),
+       context_projects = CASE
+         WHEN $5::text IS NULL THEN pai_skill_telemetry.context_projects
+         WHEN pai_skill_telemetry.context_projects @> to_jsonb($5::text)
+           THEN pai_skill_telemetry.context_projects
+         ELSE pai_skill_telemetry.context_projects || to_jsonb($5::text)
+       END`, [
+		scope,
+		input.skill_name,
+		source,
+		initialProjects,
+		proj
+	]);
+}
+/** List skill telemetry rows, most-triggered first. */
+async function querySkillTelemetry(pool, opts = {}) {
+	await ensureSkillTelemetryTable(pool);
+	const conditions = [];
+	const params = [];
+	let idx = 1;
+	conditions.push(`scope = $${idx++}`);
+	params.push(opts.scope ?? "default");
+	if (opts.status !== void 0) {
+		conditions.push(`status = $${idx++}`);
+		params.push(opts.status);
+	}
+	const where = `WHERE ${conditions.join(" AND ")}`;
+	const limit = opts.limit ?? 100;
+	params.push(limit);
+	return (await pool.query(`SELECT id, scope, skill_name, source, status,
+            trigger_count, accept_count,
+            first_triggered, last_triggered,
+            context_projects, hash, audit_status, last_audited
+     FROM pai_skill_telemetry
+     ${where}
+     ORDER BY trigger_count DESC, last_triggered DESC
+     LIMIT $${idx}`, params)).rows;
+}
+
 //#endregion
 //#region src/storage/postgres/backend.ts
 /**
@@ -520,6 +1091,7 @@ async function searchVaultNameIndex(pool, query, limit = 100) {
 const { Pool: PgPool } = pg;
 var PostgresBackend = class PostgresBackend {
 	backendType = "postgres";
+	supportsPostgresFeatures = true;
 	pool;
 	/**
 	* Ensure the per-user database exists and has the required schema.
@@ -599,13 +1171,129 @@ var PostgresBackend = class PostgresBackend {
 			await pool.query(`CREATE INDEX idx_kg_valid     ON kg_triples(valid_from, valid_to)`);
 			process.stderr.write("[pai-postgres] Migration: created kg_triples table\n");
 		}
+		await pool.query(`
+      CREATE TABLE IF NOT EXISTS kg_entities (
+        entity_id       TEXT PRIMARY KEY,
+        tenant_id       TEXT NOT NULL DEFAULT 'default',
+        name            TEXT NOT NULL,
+        type            TEXT NOT NULL DEFAULT 'unknown',
+        description     TEXT,
+        first_seen      BIGINT,
+        last_seen       BIGINT,
+        mention_count   INTEGER NOT NULL DEFAULT 1,
+        feedback_weight REAL NOT NULL DEFAULT 0.5,
+        UNIQUE (tenant_id, entity_id)
+      );
+      CREATE INDEX IF NOT EXISTS idx_kge_tenant ON kg_entities(tenant_id);
+      CREATE INDEX IF NOT EXISTS idx_kge_name   ON kg_entities(tenant_id, name);
+      CREATE INDEX IF NOT EXISTS idx_kge_type   ON kg_entities(tenant_id, type);
+
+      CREATE TABLE IF NOT EXISTS projects (
+        id               SERIAL PRIMARY KEY,
+        slug             TEXT NOT NULL UNIQUE,
+        display_name     TEXT NOT NULL,
+        root_path        TEXT NOT NULL UNIQUE,
+        encoded_dir      TEXT NOT NULL UNIQUE,
+        type             TEXT NOT NULL DEFAULT 'local'
+                           CHECK (type IN ('local','central','obsidian-linked','external')),
+        status           TEXT NOT NULL DEFAULT 'active'
+                           CHECK (status IN ('active','archived','migrating')),
+        parent_id        INTEGER REFERENCES projects(id),
+        obsidian_link    TEXT,
+        claude_notes_dir TEXT,
+        session_config   TEXT,
+        created_at       BIGINT NOT NULL,
+        updated_at       BIGINT NOT NULL,
+        archived_at      BIGINT
+      );
+
+      CREATE TABLE IF NOT EXISTS sessions (
+        id                SERIAL PRIMARY KEY,
+        project_id        INTEGER NOT NULL REFERENCES projects(id),
+        number            INTEGER NOT NULL,
+        date              TEXT NOT NULL,
+        slug              TEXT NOT NULL,
+        title             TEXT NOT NULL,
+        filename          TEXT NOT NULL,
+        status            TEXT NOT NULL DEFAULT 'open'
+                            CHECK (status IN ('open','completed','compacted')),
+        claude_session_id TEXT,
+        token_count       INTEGER,
+        created_at        BIGINT NOT NULL,
+        closed_at         BIGINT,
+        UNIQUE (project_id, number)
+      );
+
+      CREATE TABLE IF NOT EXISTS tags (
+        id   SERIAL PRIMARY KEY,
+        name TEXT NOT NULL UNIQUE
+      );
+
+      CREATE TABLE IF NOT EXISTS project_tags (
+        project_id INTEGER NOT NULL REFERENCES projects(id),
+        tag_id     INTEGER NOT NULL REFERENCES tags(id),
+        PRIMARY KEY (project_id, tag_id)
+      );
+
+      CREATE TABLE IF NOT EXISTS session_tags (
+        session_id INTEGER NOT NULL REFERENCES sessions(id),
+        tag_id     INTEGER NOT NULL REFERENCES tags(id),
+        PRIMARY KEY (session_id, tag_id)
+      );
+
+      CREATE TABLE IF NOT EXISTS aliases (
+        alias      TEXT PRIMARY KEY,
+        project_id INTEGER NOT NULL REFERENCES projects(id)
+      );
+
+      CREATE TABLE IF NOT EXISTS compaction_log (
+        id            SERIAL PRIMARY KEY,
+        project_id    INTEGER NOT NULL REFERENCES projects(id),
+        session_id    INTEGER REFERENCES sessions(id),
+        trigger       TEXT NOT NULL CHECK (trigger IN ('precompact','manual','end-session')),
+        files_written TEXT NOT NULL,
+        token_count   INTEGER,
+        created_at    BIGINT NOT NULL
+      );
+
+      CREATE TABLE IF NOT EXISTS links (
+        id                 SERIAL PRIMARY KEY,
+        session_id         INTEGER NOT NULL REFERENCES sessions(id),
+        target_project_id  INTEGER NOT NULL REFERENCES projects(id),
+        link_type          TEXT NOT NULL DEFAULT 'related'
+                             CHECK (link_type IN ('related','follow-up','reference')),
+        created_at         BIGINT NOT NULL,
+        UNIQUE (session_id, target_project_id)
+      );
+
+      CREATE INDEX IF NOT EXISTS idx_projects_slug    ON projects(slug);
+      CREATE INDEX IF NOT EXISTS idx_projects_status  ON projects(status);
+      CREATE INDEX IF NOT EXISTS idx_projects_type    ON projects(type);
+      CREATE INDEX IF NOT EXISTS idx_sessions_project ON sessions(project_id);
+      CREATE INDEX IF NOT EXISTS idx_sessions_date    ON sessions(date);
+      CREATE INDEX IF NOT EXISTS idx_sessions_status  ON sessions(status);
+      CREATE INDEX IF NOT EXISTS idx_sessions_claude  ON sessions(claude_session_id);
+      CREATE INDEX IF NOT EXISTS idx_pc_project       ON project_tags(project_id);
+    `);
+		const feedbackColCheck = await pool.query(`SELECT column_name FROM information_schema.columns
+       WHERE table_name = 'pai_chunks' AND column_name IN ('relevance_score', 'last_accessed_at')`);
+		const existingFeedbackCols = new Set(feedbackColCheck.rows.map((r) => r.column_name));
+		if (!existingFeedbackCols.has("relevance_score")) {
+			await pool.query("ALTER TABLE pai_chunks ADD COLUMN relevance_score REAL");
+			process.stderr.write("[pai-postgres] Migration: added relevance_score column to pai_chunks\n");
+		}
+		if (!existingFeedbackCols.has("last_accessed_at")) {
+			await pool.query("ALTER TABLE pai_chunks ADD COLUMN last_accessed_at BIGINT");
+			process.stderr.write("[pai-postgres] Migration: added last_accessed_at column to pai_chunks\n");
+		}
 	}
 	constructor(config) {
 		this.pool = new PgPool({
 			connectionString: config.connectionString ?? `postgresql://${config.user ?? "pai"}:${config.password ?? "pai"}@${config.host ?? "localhost"}:${config.port ?? 5432}/${config.database ?? "pai"}`,
 			max: config.maxConnections ?? 5,
 			connectionTimeoutMillis: config.connectionTimeoutMs ?? 5e3,
-			idleTimeoutMillis: 3e4
+			idleTimeoutMillis: 3e4,
+			allowExitOnIdle: true
 		});
 		this.pool.on("error", (err) => {
 			process.stderr.write(`[pai-postgres] Pool error: ${err.message}\n`);
@@ -634,6 +1322,14 @@ var PostgresBackend = class PostgresBackend {
 			client.release();
 		}
 	}
+	async getProjectStats(projectId) {
+		const filesResult = await this.pool.query("SELECT COUNT(*)::text AS n FROM pai_files WHERE project_id = $1", [projectId]);
+		const chunksResult = await this.pool.query("SELECT COUNT(*)::text AS n FROM pai_chunks WHERE project_id = $1", [projectId]);
+		return {
+			files: parseInt(filesResult.rows[0]?.n ?? "0", 10),
+			chunks: parseInt(chunksResult.rows[0]?.n ?? "0", 10)
+		};
+	}
 	/**
 	* Test the connection by running a trivial query.
 	* Returns null on success, error message on failure.
@@ -740,13 +1436,17 @@ var PostgresBackend = class PostgresBackend {
 			client.release();
 		}
 	}
-	async getUnembeddedChunkIds(projectId, limit) {
+	async getUnembeddedChunkIds(projectId, limit, after) {
 		const params = [];
 		let sql = "SELECT id, text, project_id, path FROM pai_chunks WHERE embedding IS NULL";
 		if (projectId !== void 0) {
 			params.push(projectId);
 			sql += ` AND project_id = $${params.length}`;
 		}
+		if (after) {
+			params.push(after.projectId, after.projectId, after.id);
+			sql += ` AND (project_id > $${params.length - 2} OR (project_id = $${params.length - 1} AND id > $${params.length}))`;
+		}
 		sql += " ORDER BY project_id, id";
 		if (limit !== void 0) {
 			params.push(limit);
@@ -910,8 +1610,167 @@ var PostgresBackend = class PostgresBackend {
 			limit
 		])).rows;
 	}
+	async upsertKgEntity(params) {
+		const tenantId = params.tenantId ?? "default";
+		const entityId = entityContentId(params.name, tenantId);
+		const now = Date.now();
+		await this.pool.query(`INSERT INTO kg_entities
+         (entity_id, tenant_id, name, type, description, first_seen, last_seen, mention_count, feedback_weight)
+       VALUES
+         ($1, $2, $3, $4, $5, $6, $7, 1, 0.5)
+       ON CONFLICT (entity_id) DO UPDATE SET
+         last_seen     = EXCLUDED.last_seen,
+         mention_count = kg_entities.mention_count + 1,
+         description   = COALESCE(EXCLUDED.description, kg_entities.description),
+         type          = CASE WHEN EXCLUDED.type != 'unknown' THEN EXCLUDED.type ELSE kg_entities.type END`, [
+			entityId,
+			tenantId,
+			params.name,
+			params.type ?? "unknown",
+			params.description ?? null,
+			now,
+			now
+		]);
+		return entityId;
+	}
+	async findKgEntity(name, tenantId = "default") {
+		const entityId = entityContentId(name, tenantId);
+		const row = (await this.pool.query("SELECT * FROM kg_entities WHERE entity_id = $1 AND tenant_id = $2", [entityId, tenantId])).rows[0];
+		return row ? rowToKgEntity(row) : null;
+	}
+	async listKgEntities(tenantId = "default", type, limit = 100) {
+		return (type ? await this.pool.query("SELECT * FROM kg_entities WHERE tenant_id = $1 AND type = $2 ORDER BY mention_count DESC LIMIT $3", [
+			tenantId,
+			type,
+			limit
+		]) : await this.pool.query("SELECT * FROM kg_entities WHERE tenant_id = $1 ORDER BY mention_count DESC LIMIT $2", [tenantId, limit])).rows.map(rowToKgEntity);
+	}
+	async updateEntityFeedbackWeight(entityId, normalizedRating, alpha = .1) {
+		const row = (await this.pool.query("SELECT feedback_weight FROM kg_entities WHERE entity_id = $1", [entityId])).rows[0];
+		if (!row) return;
+		const newWeight = Number(row.feedback_weight) + alpha * (normalizedRating - Number(row.feedback_weight));
+		await this.pool.query("UPDATE kg_entities SET feedback_weight = $1 WHERE entity_id = $2", [newWeight, entityId]);
+	}
+	async getChunksForFeedback(chunkIds) {
+		if (chunkIds.length === 0) return [];
+		return (await this.pool.query("SELECT id, text, relevance_score FROM pai_chunks WHERE id = ANY($1)", [chunkIds])).rows.map((r) => ({
+			id: r.id,
+			text: r.text,
+			relevanceScore: r.relevance_score
+		}));
+	}
+	async updateChunkRelevanceScore(chunkId, score) {
+		await this.pool.query("UPDATE pai_chunks SET relevance_score = $1 WHERE id = $2", [score, chunkId]);
+	}
+	async touchChunksLastAccessed(chunkIds) {
+		if (chunkIds.length === 0) return;
+		try {
+			await this.pool.query("UPDATE pai_chunks SET last_accessed_at = $1 WHERE id = ANY($2)", [Date.now(), chunkIds]);
+		} catch {}
+	}
+	async indexAll(registry) {
+		return indexAllWithBackend(this, registry);
+	}
+	async findTunnels(registry, options) {
+		return findTunnelsPostgres(this.pool, registry, options);
+	}
+	async getMemorySourcesReport() {
+		return getMemorySourcesReportPostgres(this.pool);
+	}
+	async addKgTriple(params) {
+		return addKgTriple(this.pool, params);
+	}
+	async queryKgTriples(params) {
+		return queryKgTriples(this.pool, params);
+	}
+	async invalidateKgTriple(tripleId) {
+		return invalidateKgTriple(this.pool, tripleId);
+	}
+	async getKgContradictions(subject) {
+		return getKgContradictions(this.pool, subject);
+	}
+	async getKgStats() {
+		return getKgStats(this.pool);
+	}
+	async storeObservation(obs) {
+		return storeObservation(this.pool, obs);
+	}
+	async storeObservationWithProject(registry, obs) {
+		return storeObservationWithProject(this.pool, registry, obs);
+	}
+	async queryObservations(opts) {
+		return queryObservations(this.pool, opts);
+	}
+	async queryRecentObservations(projectId, limit) {
+		return queryRecentObservations(this.pool, projectId, limit);
+	}
+	async querySessionObservations(sessionId) {
+		return querySessionObservations(this.pool, sessionId);
+	}
+	async getObservationStats() {
+		return getObservationStats(this.pool);
+	}
+	async getObservationTypesForPaths(filePaths, projectId) {
+		return getObservationTypesForPaths(this.pool, filePaths, projectId);
+	}
+	async storeSessionSummary(summary) {
+		return storeSessionSummary(this.pool, summary);
+	}
+	async queryRecentSummaries(projectId, limit) {
+		return queryRecentSummaries(this.pool, projectId, limit);
+	}
+	async recordSkillInvocation(input) {
+		return recordSkillInvocation(this.pool, input);
+	}
+	async querySkillTelemetry(opts) {
+		return querySkillTelemetry(this.pool, opts);
+	}
+	async countFilesWithPaths(paths) {
+		if (paths.length === 0) return 0;
+		const result = await this.pool.query("SELECT COUNT(*)::text AS n FROM pai_files WHERE path = ANY($1)", [paths]);
+		return parseInt(result.rows[0]?.n ?? "0", 10);
+	}
+	async renameFilePaths(moves) {
+		if (moves.length === 0) return 0;
+		const client = await this.pool.connect();
+		let filesUpdated = 0;
+		try {
+			await client.query("BEGIN");
+			for (const { oldPath, newPath } of moves) {
+				const r = await client.query("UPDATE pai_files SET path = $1 WHERE path = $2", [newPath, oldPath]);
+				filesUpdated += r.rowCount ?? 0;
+				await client.query("UPDATE pai_chunks SET path = $1 WHERE path = $2", [newPath, oldPath]);
+			}
+			await client.query("COMMIT");
+		} catch (e) {
+			await client.query("ROLLBACK");
+			throw e;
+		} finally {
+			client.release();
+		}
+		return filesUpdated;
+	}
 };
+/**
+* Postgres returns BIGINT columns (first_seen/last_seen) as strings — JS
+* numbers can't safely hold the full 64-bit range. Entity timestamps are
+* Date.now() ms and well inside Number.isSafeInteger, so a plain Number()
+* conversion here keeps the shape identical to better-sqlite3's row objects.
+*/
+function rowToKgEntity(row) {
+	return {
+		entity_id: row.entity_id,
+		tenant_id: row.tenant_id,
+		name: row.name,
+		type: row.type,
+		description: row.description,
+		first_seen: row.first_seen != null ? Number(row.first_seen) : void 0,
+		last_seen: row.last_seen != null ? Number(row.last_seen) : void 0,
+		mention_count: Number(row.mention_count),
+		feedback_weight: Number(row.feedback_weight)
+	};
+}
 
 //#endregion
 export { PostgresBackend };
-//# sourceMappingURL=postgres-CUSXWgTG.mjs.map
+//# sourceMappingURL=postgres-nvU5pShF.mjs.map