@iamem/amem 0.1.0

package/dist/db.js

@@ -0,0 +1,666 @@
+import Database from "better-sqlite3";
+import { existsSync, realpathSync } from "node:fs";
+import { resolve } from "node:path";
+import { dbPath, ensureAmemHome } from "./paths.js";
+import { detectRepoIdentity, newId, parseWorkspaceSlug, slugifyWorkspace } from "./repo-identity.js";
+import { ensureClaimsFts, reindexAllClaimsFts, reindexRepoClaimsFts, removeClaimFts, upsertClaimFts } from "./search.js";
+import { ensureClaimsEmbed, reindexRepoEmbeds, removeClaimEmbed, upsertClaimEmbed, } from "./embed.js";
+import { isDbEncryptedAtRest, resolvePassphrase, unlockDatabase } from "./crypto.js";
+const SCHEMA = `
+CREATE TABLE IF NOT EXISTS repos (
+  id TEXT PRIMARY KEY,
+  repo_key TEXT NOT NULL UNIQUE,
+  remote_url TEXT,
+  root_path TEXT NOT NULL,
+  repo_name TEXT NOT NULL,
+  default_branch TEXT NOT NULL,
+  platform TEXT,
+  created_at TEXT NOT NULL,
+  updated_at TEXT NOT NULL
+);
+
+CREATE TABLE IF NOT EXISTS components (
+  repo_id TEXT NOT NULL REFERENCES repos(id) ON DELETE CASCADE,
+  id TEXT NOT NULL,
+  name TEXT NOT NULL,
+  code_anchor TEXT,
+  PRIMARY KEY(repo_id, id)
+);
+
+CREATE TABLE IF NOT EXISTS flows (
+  repo_id TEXT NOT NULL REFERENCES repos(id) ON DELETE CASCADE,
+  id TEXT NOT NULL,
+  name TEXT NOT NULL,
+  PRIMARY KEY(repo_id, id)
+);
+
+CREATE TABLE IF NOT EXISTS claims (
+  repo_id TEXT NOT NULL REFERENCES repos(id) ON DELETE CASCADE,
+  id TEXT NOT NULL,
+  kind TEXT NOT NULL,
+  text TEXT NOT NULL,
+  code_anchors TEXT NOT NULL DEFAULT '[]',
+  source_ref TEXT,
+  created_at TEXT NOT NULL,
+  updated_at TEXT NOT NULL,
+  status TEXT NOT NULL DEFAULT 'active',
+  superseded_by TEXT,
+  pinned INTEGER NOT NULL DEFAULT 0,
+  PRIMARY KEY(repo_id, id)
+);
+
+CREATE TABLE IF NOT EXISTS edges (
+  repo_id TEXT NOT NULL REFERENCES repos(id) ON DELETE CASCADE,
+  id TEXT NOT NULL,
+  from_id TEXT NOT NULL,
+  from_type TEXT NOT NULL,
+  to_id TEXT NOT NULL,
+  to_type TEXT NOT NULL,
+  kind TEXT NOT NULL,
+  PRIMARY KEY(repo_id, id)
+);
+
+CREATE TABLE IF NOT EXISTS agent_sessions (
+  platform TEXT NOT NULL,
+  session_id TEXT NOT NULL,
+  repo_id TEXT NOT NULL REFERENCES repos(id) ON DELETE CASCADE,
+  last_seen TEXT NOT NULL,
+  PRIMARY KEY(platform, session_id)
+);
+
+CREATE TABLE IF NOT EXISTS usage_events (
+  id TEXT PRIMARY KEY,
+  repo_id TEXT NOT NULL REFERENCES repos(id) ON DELETE CASCADE,
+  platform TEXT NOT NULL,
+  session_id TEXT,
+  query TEXT NOT NULL,
+  claim_ids TEXT NOT NULL,
+  anchors_count INTEGER NOT NULL,
+  claims_count INTEGER NOT NULL,
+  packet_tokens INTEGER NOT NULL,
+  estimated_tokens_saved INTEGER NOT NULL,
+  reported_tokens_saved INTEGER,
+  created_at TEXT NOT NULL,
+  local_ms INTEGER,
+  estimated_ms_saved INTEGER,
+  kind TEXT
+);
+
+CREATE TABLE IF NOT EXISTS setup_state (
+  repo_id TEXT PRIMARY KEY REFERENCES repos(id) ON DELETE CASCADE,
+  platforms TEXT NOT NULL,
+  setup_completed_at TEXT,
+  updated_at TEXT NOT NULL
+);
+
+CREATE TABLE IF NOT EXISTS conversation_notes (
+  id TEXT PRIMARY KEY,
+  repo_id TEXT NOT NULL REFERENCES repos(id) ON DELETE CASCADE,
+  platform TEXT NOT NULL,
+  session_id TEXT,
+  role TEXT NOT NULL,
+  text TEXT NOT NULL,
+  created_at TEXT NOT NULL
+);
+
+CREATE TABLE IF NOT EXISTS proposal_drafts (
+  id TEXT PRIMARY KEY,
+  repo_id TEXT NOT NULL REFERENCES repos(id) ON DELETE CASCADE,
+  platform TEXT NOT NULL,
+  session_id TEXT,
+  title TEXT NOT NULL,
+  proposal_json TEXT NOT NULL,
+  status TEXT NOT NULL DEFAULT 'pending',
+  source TEXT NOT NULL DEFAULT 'session-end',
+  created_at TEXT NOT NULL,
+  updated_at TEXT NOT NULL
+);
+
+CREATE INDEX IF NOT EXISTS claims_repo_idx ON claims(repo_id);
+CREATE INDEX IF NOT EXISTS edges_repo_idx ON edges(repo_id);
+CREATE INDEX IF NOT EXISTS components_repo_idx ON components(repo_id);
+CREATE INDEX IF NOT EXISTS flows_repo_idx ON flows(repo_id);
+CREATE INDEX IF NOT EXISTS agent_sessions_repo_idx ON agent_sessions(repo_id);
+CREATE INDEX IF NOT EXISTS usage_events_repo_idx ON usage_events(repo_id);
+CREATE INDEX IF NOT EXISTS usage_events_created_idx ON usage_events(created_at);
+CREATE INDEX IF NOT EXISTS conversation_notes_repo_idx ON conversation_notes(repo_id);
+CREATE INDEX IF NOT EXISTS conversation_notes_created_idx ON conversation_notes(created_at);
+CREATE INDEX IF NOT EXISTS proposal_drafts_repo_idx ON proposal_drafts(repo_id);
+CREATE INDEX IF NOT EXISTS proposal_drafts_status_idx ON proposal_drafts(status);
+`;
+let cached = null;
+export function openDb() {
+    if (cached)
+        return cached;
+    ensureAmemHome();
+    if (isDbEncryptedAtRest()) {
+        try {
+            unlockDatabase(resolvePassphrase(process.env.AMEM_PASSPHRASE));
+        }
+        catch (error) {
+            const detail = error instanceof Error ? error.message : String(error);
+            throw new Error(`amem database is encrypted at rest. Unlock with \`amem unlock --passphrase …\` or set AMEM_PASSPHRASE. (${detail})`);
+        }
+    }
+    const db = new Database(dbPath());
+    db.pragma("journal_mode = WAL");
+    db.pragma("busy_timeout = 5000");
+    db.pragma("foreign_keys = ON");
+    db.exec(SCHEMA);
+    migrateUsageEvents(db);
+    migrateClaimsColumns(db);
+    ensureClaimsFts(db);
+    migrateClaimsFtsBootstrap(db);
+    ensureProposalDrafts(db);
+    ensureClaimsEmbed(db);
+    cached = db;
+    return db;
+}
+function migrateUsageEvents(db) {
+    const cols = db.prepare("PRAGMA table_info(usage_events)").all();
+    const have = new Set(cols.map((c) => c.name));
+    if (!have.has("local_ms"))
+        db.exec("ALTER TABLE usage_events ADD COLUMN local_ms INTEGER");
+    if (!have.has("estimated_ms_saved")) {
+        db.exec("ALTER TABLE usage_events ADD COLUMN estimated_ms_saved INTEGER");
+    }
+    if (!have.has("kind"))
+        db.exec("ALTER TABLE usage_events ADD COLUMN kind TEXT");
+}
+function migrateClaimsColumns(db) {
+    const cols = db.prepare("PRAGMA table_info(claims)").all();
+    const have = new Set(cols.map((c) => c.name));
+    if (!have.has("status")) {
+        db.exec(`ALTER TABLE claims ADD COLUMN status TEXT NOT NULL DEFAULT 'active'`);
+    }
+    if (!have.has("superseded_by")) {
+        db.exec(`ALTER TABLE claims ADD COLUMN superseded_by TEXT`);
+    }
+    if (!have.has("pinned")) {
+        db.exec(`ALTER TABLE claims ADD COLUMN pinned INTEGER NOT NULL DEFAULT 0`);
+    }
+}
+function ensureProposalDrafts(db) {
+    db.exec(`
+    CREATE TABLE IF NOT EXISTS proposal_drafts (
+      id TEXT PRIMARY KEY,
+      repo_id TEXT NOT NULL REFERENCES repos(id) ON DELETE CASCADE,
+      platform TEXT NOT NULL,
+      session_id TEXT,
+      title TEXT NOT NULL,
+      proposal_json TEXT NOT NULL,
+      status TEXT NOT NULL DEFAULT 'pending',
+      source TEXT NOT NULL DEFAULT 'session-end',
+      created_at TEXT NOT NULL,
+      updated_at TEXT NOT NULL
+    );
+    CREATE INDEX IF NOT EXISTS proposal_drafts_repo_idx ON proposal_drafts(repo_id);
+    CREATE INDEX IF NOT EXISTS proposal_drafts_status_idx ON proposal_drafts(status);
+  `);
+}
+/** One-shot FTS rebuild flag so upgrades populate the index. */
+function migrateClaimsFtsBootstrap(db) {
+    db.exec(`
+    CREATE TABLE IF NOT EXISTS amem_meta (
+      key TEXT PRIMARY KEY,
+      value TEXT NOT NULL
+    );
+  `);
+    const row = db
+        .prepare(`SELECT value FROM amem_meta WHERE key = 'claims_fts_v1'`)
+        .get();
+    if (row?.value === "1")
+        return;
+    reindexAllClaimsFts(db);
+    db.prepare(`INSERT INTO amem_meta (key, value) VALUES ('claims_fts_v1', '1')
+     ON CONFLICT(key) DO UPDATE SET value = excluded.value`).run();
+}
+export function closeDb() {
+    if (cached) {
+        cached.close();
+        cached = null;
+    }
+}
+function nowIso() {
+    return new Date().toISOString();
+}
+export function upsertRepo(identity = detectRepoIdentity(), platform) {
+    const db = openDb();
+    const existing = db
+        .prepare("SELECT * FROM repos WHERE repo_key = ?")
+        .get(identity.repoKey);
+    const ts = nowIso();
+    if (existing) {
+        db.prepare(`UPDATE repos SET remote_url = ?, root_path = ?, repo_name = ?, default_branch = ?,
+       platform = COALESCE(?, platform), updated_at = ? WHERE id = ?`).run(identity.remoteUrl, identity.rootPath, identity.repoName, identity.defaultBranch, platform ?? null, ts, existing.id);
+        return db.prepare("SELECT * FROM repos WHERE id = ?").get(existing.id);
+    }
+    const id = newId("repo");
+    db.prepare(`INSERT INTO repos (id, repo_key, remote_url, root_path, repo_name, default_branch, platform, created_at, updated_at)
+     VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`).run(id, identity.repoKey, identity.remoteUrl, identity.rootPath, identity.repoName, identity.defaultBranch, platform ?? null, ts, ts);
+    return db.prepare("SELECT * FROM repos WHERE id = ?").get(id);
+}
+function normalizeFsPath(p) {
+    const resolved = resolve(p).replace(/[/\\]+$/, "");
+    try {
+        if (existsSync(resolved))
+            return realpathSync(resolved);
+    }
+    catch {
+        // ignore
+    }
+    return resolved;
+}
+export function getRepoByCwd(cwd = process.cwd()) {
+    const identity = detectRepoIdentity(cwd);
+    const db = openDb();
+    const byKey = db
+        .prepare("SELECT * FROM repos WHERE repo_key = ?")
+        .get(identity.repoKey);
+    if (byKey)
+        return byKey;
+    const byExact = db
+        .prepare("SELECT * FROM repos WHERE root_path = ?")
+        .get(identity.rootPath);
+    if (byExact)
+        return byExact;
+    const want = normalizeFsPath(identity.rootPath);
+    const rows = db.prepare("SELECT * FROM repos").all();
+    return rows.find((r) => normalizeFsPath(r.root_path) === want) ?? null;
+}
+export function requireRepo(cwd = process.cwd()) {
+    const repo = getRepoByCwd(cwd);
+    if (!repo) {
+        throw new Error("No amem binding here. Run `amem init --platform cursor|claude` in a git repo, or `amem init --workspace <name>` for an app.");
+    }
+    return repo;
+}
+export function getMeta(key) {
+    const row = openDb()
+        .prepare(`SELECT value FROM amem_meta WHERE key = ?`)
+        .get(key);
+    return row?.value ?? null;
+}
+export function setMeta(key, value) {
+    openDb()
+        .prepare(`INSERT INTO amem_meta (key, value) VALUES (?, ?)
+       ON CONFLICT(key) DO UPDATE SET value = excluded.value`)
+        .run(key, value);
+}
+export function listClaims(repoId, opts = {}) {
+    if (opts.includeSuperseded) {
+        return openDb()
+            .prepare(`SELECT * FROM claims WHERE repo_id = ?
+         ORDER BY COALESCE(pinned, 0) DESC, updated_at DESC`)
+            .all(repoId);
+    }
+    return openDb()
+        .prepare(`SELECT * FROM claims WHERE repo_id = ?
+       AND COALESCE(status, 'active') = 'active'
+       ORDER BY COALESCE(pinned, 0) DESC, updated_at DESC`)
+        .all(repoId);
+}
+export function listClaimsAll(opts = {}) {
+    if (opts.includeSuperseded) {
+        return openDb()
+            .prepare(`SELECT * FROM claims
+         ORDER BY COALESCE(pinned, 0) DESC, updated_at DESC`)
+            .all();
+    }
+    return openDb()
+        .prepare(`SELECT * FROM claims
+       WHERE COALESCE(status, 'active') = 'active'
+       ORDER BY COALESCE(pinned, 0) DESC, updated_at DESC`)
+        .all();
+}
+export function getClaim(repoId, claimId) {
+    return (openDb()
+        .prepare("SELECT * FROM claims WHERE repo_id = ? AND id = ?")
+        .get(repoId, claimId) ?? null);
+}
+export function updateClaim(repoId, claimId, patch) {
+    const existing = getClaim(repoId, claimId);
+    if (!existing)
+        return null;
+    const ts = nowIso();
+    const text = patch.text !== undefined ? patch.text.trim() : existing.text;
+    const kind = patch.kind !== undefined ? patch.kind.trim() : existing.kind;
+    const anchors = patch.code_anchors !== undefined
+        ? JSON.stringify(patch.code_anchors)
+        : existing.code_anchors;
+    const pinned = patch.pinned !== undefined ? (patch.pinned ? 1 : 0) : (existing.pinned ?? 0);
+    if (!text || !kind)
+        throw new Error("claim text and kind are required");
+    openDb()
+        .prepare(`UPDATE claims SET text = ?, kind = ?, code_anchors = ?, pinned = ?, updated_at = ?
+       WHERE repo_id = ? AND id = ?`)
+        .run(text, kind, anchors, pinned, ts, repoId, claimId);
+    const updated = getClaim(repoId, claimId);
+    if (updated) {
+        upsertClaimFts(openDb(), updated);
+        upsertClaimEmbed(openDb(), updated);
+    }
+    return updated;
+}
+export function setClaimPinned(repoId, claimId, pinned) {
+    return updateClaim(repoId, claimId, { pinned });
+}
+export function setClaimStatus(repoId, claimId, status) {
+    const existing = getClaim(repoId, claimId);
+    if (!existing)
+        return null;
+    const ts = nowIso();
+    openDb()
+        .prepare(`UPDATE claims SET status = ?, updated_at = ? WHERE repo_id = ? AND id = ?`)
+        .run(status, ts, repoId, claimId);
+    const updated = getClaim(repoId, claimId);
+    if (updated) {
+        upsertClaimFts(openDb(), updated);
+        if ((updated.status ?? "active") !== "active")
+            removeClaimEmbed(openDb(), repoId, claimId);
+        else
+            upsertClaimEmbed(openDb(), updated);
+    }
+    return updated;
+}
+export function deleteClaim(repoId, claimId) {
+    const db = openDb();
+    removeClaimFts(db, repoId, claimId);
+    removeClaimEmbed(db, repoId, claimId);
+    const result = db.prepare(`DELETE FROM claims WHERE repo_id = ? AND id = ?`).run(repoId, claimId);
+    return Number(result.changes ?? 0) > 0;
+}
+/** Reindex FTS + local embeddings for one repo (after propose apply / wipe helpers). */
+export function reindexClaimsSearch(repoId) {
+    const db = openDb();
+    reindexRepoClaimsFts(db, repoId);
+    reindexRepoEmbeds(db, repoId);
+}
+export function listComponents(repoId) {
+    return openDb()
+        .prepare("SELECT * FROM components WHERE repo_id = ? ORDER BY name")
+        .all(repoId);
+}
+export function listComponentsAll() {
+    return openDb().prepare("SELECT * FROM components ORDER BY name").all();
+}
+export function listFlows(repoId) {
+    return openDb()
+        .prepare("SELECT * FROM flows WHERE repo_id = ? ORDER BY name")
+        .all(repoId);
+}
+export function listFlowsAll() {
+    return openDb().prepare("SELECT * FROM flows ORDER BY name").all();
+}
+export function listEdges(repoId) {
+    return openDb()
+        .prepare("SELECT * FROM edges WHERE repo_id = ?")
+        .all(repoId);
+}
+export function listEdgesAll() {
+    return openDb().prepare("SELECT * FROM edges").all();
+}
+export function wipeRepo(repoId) {
+    const db = openDb();
+    const claimIds = db
+        .prepare("SELECT id FROM claims WHERE repo_id = ?")
+        .all(repoId);
+    for (const c of claimIds) {
+        removeClaimFts(db, repoId, c.id);
+        removeClaimEmbed(db, repoId, c.id);
+    }
+    db.prepare("DELETE FROM repos WHERE id = ?").run(repoId);
+}
+/** Delete every bound repo (cascade clears claims/flows/usage). Returns count wiped. */
+export function wipeAllRepos() {
+    const db = openDb();
+    const row = db.prepare("SELECT COUNT(*) AS c FROM repos").get();
+    const repos = db.prepare("SELECT id FROM repos").all();
+    for (const r of repos) {
+        const claimIds = db
+            .prepare("SELECT id FROM claims WHERE repo_id = ?")
+            .all(r.id);
+        for (const c of claimIds) {
+            removeClaimFts(db, r.id, c.id);
+            removeClaimEmbed(db, r.id, c.id);
+        }
+    }
+    db.exec("DELETE FROM repos");
+    return row.c;
+}
+export function touchSession(platform, sessionId, repoId) {
+    openDb()
+        .prepare(`INSERT INTO agent_sessions (platform, session_id, repo_id, last_seen)
+       VALUES (?, ?, ?, ?)
+       ON CONFLICT(platform, session_id) DO UPDATE SET
+         repo_id = excluded.repo_id,
+         last_seen = excluded.last_seen`)
+        .run(platform, sessionId, repoId, nowIso());
+}
+export function insertUsageEvent(input) {
+    const id = newId("usage");
+    const ts = nowIso();
+    if (input.sessionId) {
+        touchSession(input.platform, input.sessionId, input.repoId);
+    }
+    openDb()
+        .prepare(`INSERT INTO usage_events (
+         id, repo_id, platform, session_id, query, claim_ids,
+         anchors_count, claims_count, packet_tokens, estimated_tokens_saved,
+         reported_tokens_saved, created_at, local_ms, estimated_ms_saved, kind
+       ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, NULL, ?, ?, ?, ?)`)
+        .run(id, input.repoId, input.platform, input.sessionId ?? null, input.query, JSON.stringify(input.claimIds), input.anchorsCount, input.claimsCount, input.packetTokens, input.estimatedTokensSaved, ts, input.localMs ?? null, input.estimatedMsSaved ?? null, input.kind ?? null);
+    return openDb().prepare("SELECT * FROM usage_events WHERE id = ?").get(id);
+}
+export function listSessions(repoId) {
+    return openDb()
+        .prepare(`SELECT * FROM agent_sessions WHERE repo_id = ? ORDER BY last_seen DESC`)
+        .all(repoId);
+}
+export function listSessionsAll() {
+    return openDb()
+        .prepare(`SELECT * FROM agent_sessions ORDER BY last_seen DESC`)
+        .all();
+}
+export function setReportedTokensSaved(eventId, saved) {
+    const row = openDb()
+        .prepare("SELECT * FROM usage_events WHERE id = ?")
+        .get(eventId);
+    if (!row)
+        throw new Error(`Unknown usage event: ${eventId}`);
+    openDb()
+        .prepare("UPDATE usage_events SET reported_tokens_saved = ? WHERE id = ?")
+        .run(saved, eventId);
+    return openDb().prepare("SELECT * FROM usage_events WHERE id = ?").get(eventId);
+}
+export function setReportedOnLatest(repoId, platform, saved) {
+    const row = openDb()
+        .prepare(`SELECT * FROM usage_events WHERE repo_id = ? AND platform = ?
+       ORDER BY created_at DESC LIMIT 1`)
+        .get(repoId, platform);
+    if (!row)
+        throw new Error("No usage events to update for this platform");
+    return setReportedTokensSaved(row.id, saved);
+}
+export function listUsageEvents(opts) {
+    const days = opts.days ?? 30;
+    const since = new Date(Date.now() - days * 24 * 60 * 60 * 1000).toISOString();
+    if (opts.repoId) {
+        return openDb()
+            .prepare(`SELECT * FROM usage_events WHERE repo_id = ? AND created_at >= ?
+         ORDER BY created_at DESC`)
+            .all(opts.repoId, since);
+    }
+    return openDb()
+        .prepare(`SELECT * FROM usage_events WHERE created_at >= ? ORDER BY created_at DESC`)
+        .all(since);
+}
+export function listRepos() {
+    return openDb()
+        .prepare("SELECT * FROM repos ORDER BY updated_at DESC")
+        .all();
+}
+export function getSetupState(repoId) {
+    return (openDb()
+        .prepare("SELECT * FROM setup_state WHERE repo_id = ?")
+        .get(repoId) ?? null);
+}
+export function upsertSetupState(repoId, platforms, completed) {
+    const ts = nowIso();
+    const existing = getSetupState(repoId);
+    const completedAt = completed
+        ? (existing?.setup_completed_at ?? ts)
+        : existing?.setup_completed_at ?? null;
+    openDb()
+        .prepare(`INSERT INTO setup_state (repo_id, platforms, setup_completed_at, updated_at)
+       VALUES (?, ?, ?, ?)
+       ON CONFLICT(repo_id) DO UPDATE SET
+         platforms = excluded.platforms,
+         setup_completed_at = COALESCE(excluded.setup_completed_at, setup_state.setup_completed_at),
+         updated_at = excluded.updated_at`)
+        .run(repoId, JSON.stringify(platforms), completed ? completedAt ?? ts : completedAt, ts);
+    if (completed && !existing?.setup_completed_at) {
+        openDb()
+            .prepare("UPDATE setup_state SET setup_completed_at = ? WHERE repo_id = ?")
+            .run(ts, repoId);
+    }
+    return getSetupState(repoId);
+}
+export function getRepoById(id) {
+    return (openDb().prepare("SELECT * FROM repos WHERE id = ?").get(id) ??
+        null);
+}
+export function getRepoByName(name) {
+    const byId = getRepoById(name);
+    if (byId)
+        return byId;
+    const raw = name.trim();
+    if (!raw)
+        return null;
+    let slug;
+    try {
+        slug = slugifyWorkspace(raw);
+    }
+    catch {
+        return null;
+    }
+    const rows = listRepos();
+    const lower = raw.toLowerCase();
+    return (rows.find((r) => parseWorkspaceSlug(r.remote_url) === slug) ??
+        rows.find((r) => r.repo_name.toLowerCase() === lower) ??
+        rows.find((r) => {
+            try {
+                return slugifyWorkspace(r.repo_name) === slug;
+            }
+            catch {
+                return false;
+            }
+        }) ??
+        null);
+}
+/** Change a workspace display name. Keeps id, repo_key, and amem:// slug so memory stays bound. */
+export function renameWorkspace(repoId, displayName) {
+    const repo = getRepoById(repoId);
+    if (!repo)
+        throw new Error("Workspace not found");
+    if (!parseWorkspaceSlug(repo.remote_url)) {
+        throw new Error("Only named workspaces can be renamed (git repos follow the folder / remote name)");
+    }
+    const label = displayName.trim().replace(/\s+/g, " ").slice(0, 80);
+    if (!label)
+        throw new Error("Name required");
+    slugifyWorkspace(label);
+    const ts = nowIso();
+    openDb()
+        .prepare("UPDATE repos SET repo_name = ?, updated_at = ? WHERE id = ?")
+        .run(label, ts, repoId);
+    return getRepoById(repoId);
+}
+export function insertConversationNote(input) {
+    const id = newId("note");
+    const ts = nowIso();
+    const text = input.text.trim().slice(0, 2000);
+    openDb()
+        .prepare(`INSERT INTO conversation_notes (id, repo_id, platform, session_id, role, text, created_at)
+       VALUES (?, ?, ?, ?, ?, ?, ?)`)
+        .run(id, input.repoId, input.platform, input.sessionId ?? null, input.role, text, ts);
+    pruneConversationNotes(input.repoId);
+    return openDb()
+        .prepare("SELECT * FROM conversation_notes WHERE id = ?")
+        .get(id);
+}
+function pruneConversationNotes(repoId) {
+    const cutoff = openDb()
+        .prepare(`SELECT created_at FROM conversation_notes WHERE repo_id = ?
+       ORDER BY created_at DESC LIMIT 1 OFFSET 100`)
+        .get(repoId);
+    if (!cutoff)
+        return;
+    openDb()
+        .prepare("DELETE FROM conversation_notes WHERE repo_id = ? AND created_at < ?")
+        .run(repoId, cutoff.created_at);
+}
+export function listConversationNotes(repoId, limit = 40) {
+    return openDb()
+        .prepare(`SELECT * FROM conversation_notes WHERE repo_id = ?
+       ORDER BY created_at DESC LIMIT ?`)
+        .all(repoId, limit);
+}
+export function insertProposalDraft(input) {
+    const id = newId("draft");
+    const ts = nowIso();
+    openDb()
+        .prepare(`INSERT INTO proposal_drafts (
+         id, repo_id, platform, session_id, title, proposal_json, status, source, created_at, updated_at
+       ) VALUES (?, ?, ?, ?, ?, ?, 'pending', ?, ?, ?)`)
+        .run(id, input.repoId, input.platform, input.sessionId ?? null, input.title.slice(0, 200), JSON.stringify(input.proposal), input.source ?? "session-end", ts, ts);
+    return getProposalDraft(id);
+}
+export function getProposalDraft(id) {
+    return (openDb().prepare(`SELECT * FROM proposal_drafts WHERE id = ?`).get(id) ?? null);
+}
+export function listProposalDrafts(repoId, opts = {}) {
+    const limit = opts.limit ?? 40;
+    if (opts.status) {
+        return openDb()
+            .prepare(`SELECT * FROM proposal_drafts WHERE repo_id = ? AND status = ?
+         ORDER BY created_at DESC LIMIT ?`)
+            .all(repoId, opts.status, limit);
+    }
+    return openDb()
+        .prepare(`SELECT * FROM proposal_drafts WHERE repo_id = ?
+       ORDER BY created_at DESC LIMIT ?`)
+        .all(repoId, limit);
+}
+export function listProposalDraftsAll(opts = {}) {
+    const limit = opts.limit ?? 80;
+    if (opts.status) {
+        return openDb()
+            .prepare(`SELECT * FROM proposal_drafts WHERE status = ?
+         ORDER BY created_at DESC LIMIT ?`)
+            .all(opts.status, limit);
+    }
+    return openDb()
+        .prepare(`SELECT * FROM proposal_drafts ORDER BY created_at DESC LIMIT ?`)
+        .all(limit);
+}
+export function countProposalDrafts(repoId, status = "pending") {
+    const row = openDb()
+        .prepare(`SELECT COUNT(*) AS n FROM proposal_drafts WHERE repo_id = ? AND status = ?`)
+        .get(repoId, status);
+    return Number(row?.n || 0);
+}
+export function countProposalDraftsAll(status = "pending") {
+    const row = openDb()
+        .prepare(`SELECT COUNT(*) AS n FROM proposal_drafts WHERE status = ?`)
+        .get(status);
+    return Number(row?.n || 0);
+}
+export function setProposalDraftStatus(id, status) {
+    const ts = nowIso();
+    openDb()
+        .prepare(`UPDATE proposal_drafts SET status = ?, updated_at = ? WHERE id = ?`)
+        .run(status, ts, id);
+    return getProposalDraft(id);
+}
+export { nowIso };

package/dist/draft-quality.d.ts

@@ -0,0 +1,19 @@
+import { type ProposalDraftRow } from "./db.js";
+import { type ClaimConflict, type Proposal } from "./proposal.js";
+export declare const REJECT_SCORE = 25;
+export type QualityLabel = "high" | "medium" | "low" | "reject";
+export type DraftQuality = {
+    score: number;
+    label: QualityLabel;
+    reasons: string[];
+    reject: boolean;
+};
+export type DecoratedDraft = ProposalDraftRow & {
+    quality: DraftQuality;
+    conflicts: ClaimConflict[];
+};
+/** Confidence 0–100 for a session-end / miss→learn proposal. */
+export declare function scoreProposal(proposal: Proposal): DraftQuality;
+export declare function parseDraftProposal(draft: ProposalDraftRow): Proposal;
+export declare function decorateDraft(draft: ProposalDraftRow, existingActive?: import("./db.js").ClaimRow[]): DecoratedDraft;
+export declare function decorateDrafts(drafts: ProposalDraftRow[]): DecoratedDraft[];