dsh-continual-evolve 0.14.2 → 0.15.1

package/lib/store-apply.js

@@ -0,0 +1,177 @@
+import { fieldGateReasons, isValidMemoryId, slugifyId, } from "./memory-rules.js";
+function recordOf(row) {
+    return {
+        workspaceId: row.workspace_id,
+        id: row.id,
+        type: row.type,
+        title: row.title,
+        description: row.description,
+        body: row.body,
+        status: row.status,
+        sourceSession: row.source_session,
+        sourceSeqs: row.source_seqs,
+        sourceRun: row.source_run,
+        createdAt: row.created_at,
+        updatedAt: row.updated_at,
+    };
+}
+const INSERT_SQL = "INSERT INTO memories (workspace_id, id, type, title, description, body, status, source_session, source_seqs, source_run, created_at, updated_at) " +
+    "VALUES (?, ?, ?, ?, ?, ?, 'active', ?, ?, ?, ?, ?)";
+const UPDATE_SQL = "UPDATE memories SET type = ?, title = ?, description = ?, body = ?, updated_at = ? WHERE workspace_id = ? AND id = ?";
+const DELETE_SQL = "DELETE FROM memories WHERE workspace_id = ? AND id = ?";
+const FTS_DROP_SQL = "DELETE FROM memories_fts WHERE rowid IN (SELECT rowid FROM memories_fts WHERE workspace_id = ? AND id = ?)";
+const FTS_INSERT_SQL = "INSERT INTO memories_fts (workspace_id, id, title, description, body) " +
+    "SELECT workspace_id, id, title, description, body FROM memories WHERE workspace_id = ? AND id = ?";
+/** Re-sync the FTS row for one memory id from its table row (delete + insert). */
+function syncFts(db, workspaceId, id) {
+    db.database.prepare(FTS_DROP_SQL).run(workspaceId, id);
+    db.database.prepare(FTS_INSERT_SQL).run(workspaceId, id);
+}
+/**
+ * Validate and apply the whole batch atomically. A batch with any invalid
+ * proposal mutates nothing and still lands a `rejected` ledger row; an
+ * applied batch lands an `applied` row with full before/after snapshots.
+ */
+export function applyProposals(db, ctx, proposals) {
+    const started = Date.now();
+    const outcomes = [];
+    const files = [];
+    const runId = ctx.runId ?? (ctx.trigger === "explicit" ? "explicit" : undefined);
+    const get = db.database.prepare("SELECT * FROM memories WHERE workspace_id = ? AND id = ?");
+    const insert = db.database.prepare(INSERT_SQL);
+    const update = db.database.prepare(UPDATE_SQL);
+    const del = db.database.prepare(DELETE_SQL);
+    db.database.exec("BEGIN");
+    for (const proposal of proposals) {
+        const outcome = applyOne(db, ctx, proposal, { get, insert, update, del }, files);
+        outcomes.push(outcome);
+        if (!outcome.ok) {
+            break;
+        }
+    }
+    const applied = outcomes.every((outcome) => outcome.ok);
+    db.database.exec(applied ? "COMMIT" : "ROLLBACK");
+    const ledger = {
+        runId,
+        sessionId: ctx.sessionId,
+        workspaceId: ctx.workspaceId,
+        trigger: ctx.trigger,
+        decision: ctx.decision,
+        status: applied ? "applied" : "rejected",
+        durationMs: Date.now() - started,
+        model: ctx.model,
+        usage: ctx.usage,
+        files: applied ? files : [],
+    };
+    if (!applied) {
+        ledger.decision = `${ctx.decision ?? ""} first failure: ${outcomes.find((o) => !o.ok)?.reason ?? ""}`.trim();
+    }
+    writeLedger(db.database.prepare(LEDGER_SQL), ledger);
+    return { outcomes, applied };
+}
+const LEDGER_SQL = "INSERT INTO extraction_log (run_id, ts, session_id, workspace_id, trigger, decision, skip_reason, status, duration_ms, model, usage, files) " +
+    "VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)";
+function writeLedger(stmt, entry) {
+    stmt.run(entry.runId ?? null, new Date().toISOString(), entry.sessionId ?? null, entry.workspaceId ?? null, entry.trigger, entry.decision ?? null, entry.skipReason ?? null, entry.status ?? null, entry.durationMs ?? null, entry.model ?? null, entry.usage === undefined ? null : JSON.stringify(entry.usage), entry.files === undefined ? null : JSON.stringify(entry.files));
+}
+/** Validate one proposal and land it; appends the audit payload on success. */
+function applyOne(db, ctx, proposal, stmts, files) {
+    const action = proposal.action;
+    if (action !== "create" && action !== "update" && action !== "delete") {
+        return fail(proposal, `unknown action ${String(action)}`);
+    }
+    const id = idFor(proposal);
+    if (!isValidMemoryId(id)) {
+        return fail(proposal, id.length === 0 ? "id missing and cannot be derived from the title" : `malformed id "${id}"`);
+    }
+    const existingRow = stmts.get.get(ctx.workspaceId, id);
+    const existing = existingRow === undefined ? undefined : recordOf(existingRow);
+    if (action === "delete") {
+        if (existing === undefined) {
+            return fail(proposal, `no memory "${id}" to delete`);
+        }
+        stmts.del.run(ctx.workspaceId, id);
+        syncFts(db, ctx.workspaceId, id);
+        files.push({ id, action, before: existing });
+        return { id, action, ok: true };
+    }
+    const fields = mergedFields(proposal, existing, action);
+    if ("reason" in fields) {
+        return fail(proposal, fields.reason);
+    }
+    const reasons = fieldGateReasons(fields.fields);
+    if (reasons.length > 0) {
+        return fail(proposal, reasons[0] ?? "invalid record");
+    }
+    if (action === "create") {
+        if (existing !== undefined) {
+            return fail(proposal, `memory "${id}" already exists — update it instead of creating a duplicate`);
+        }
+        const now = db.now();
+        stmts.insert.run(ctx.workspaceId, id, fields.fields.type, fields.fields.title, fields.fields.description, fields.fields.body, ctx.sessionId ?? null, proposal.sourceSeqs ?? null, ctx.runId ?? (ctx.trigger === "explicit" ? "explicit" : null), now, now);
+        syncFts(db, ctx.workspaceId, id);
+        files.push({
+            id,
+            action,
+            after: recordOf(stmts.get.get(ctx.workspaceId, id)),
+            sourceSeqs: proposal.sourceSeqs,
+        });
+        return { id, action, ok: true };
+    }
+    // action === "update"
+    if (existing === undefined) {
+        return fail(proposal, `no memory "${id}" to update — create it instead`);
+    }
+    stmts.update.run(fields.fields.type, fields.fields.title, fields.fields.description, fields.fields.body, db.now(), ctx.workspaceId, id);
+    syncFts(db, ctx.workspaceId, id);
+    files.push({ id, action, before: existing, after: recordOf(stmts.get.get(ctx.workspaceId, id)) });
+    return { id, action, ok: true };
+}
+/** Failure outcome, carrying the proposal id when one was readable. */
+function fail(proposal, reason) {
+    return { id: proposal.id ?? "", action: proposal.action, ok: false, reason };
+}
+/** The proposal id, derived from the title (slug, CJK-hash fallback) on create. */
+function idFor(proposal) {
+    if (proposal.id !== undefined && proposal.id.trim().length > 0) {
+        return proposal.id.trim();
+    }
+    if (proposal.action === "create" && typeof proposal.title === "string") {
+        return slugifyId(proposal.title);
+    }
+    return "";
+}
+/**
+ * The merged field values a create/update would write. Create needs all
+ * fields supplied; update merges over the stored record. A missing-required
+ * result carries a `reason` instead.
+ */
+function mergedFields(proposal, existing, action) {
+    const pick = (value, fallback) => typeof value === "string" ? value : fallback;
+    if (action === "create") {
+        if (typeof proposal.type !== "string" || typeof proposal.title !== "string" ||
+            typeof proposal.description !== "string" || typeof proposal.body !== "string") {
+            return { reason: "create requires id?, type, title, description, body" };
+        }
+        return {
+            fields: {
+                type: proposal.type,
+                title: proposal.title,
+                description: proposal.description,
+                body: proposal.body,
+            },
+        };
+    }
+    if (existing === undefined) {
+        return { reason: "no memory to merge into" };
+    }
+    return {
+        fields: {
+            type: (typeof proposal.type === "string" ? proposal.type : existing.type),
+            title: pick(proposal.title, existing.title),
+            description: pick(proposal.description, existing.description),
+            body: pick(proposal.body, existing.body),
+        },
+    };
+}
+//# sourceMappingURL=store-apply.js.map

package/lib/store.d.ts

@@ -0,0 +1,99 @@
+import type { MemoryProposal } from "./memory-rules.js";
+import { type ProposalContext, type ProposalOutcome } from "./store-apply.js";
+export type { MemoryProposal, ProposalContext, ProposalOutcome };
+/** Thrown when the runtime lacks `node:sqlite` — the degrade signal. */
+export declare class StoreUnavailableError extends Error {
+}
+/** State-table keys owned by the store (partitioned per workspace, `""` = global). */
+export declare const CURSOR_KEY_PREFIX = "seq:";
+export declare const PATROL_STATE_KEY = "patrol:last";
+export declare const MD_IMPORT_STATE_KEY = "md-imported";
+/** Global partition id for workspace-independent state rows. */
+export declare const GLOBAL_WORKSPACE = "";
+/** Preview size cap for the card's content endpoint (ZCode's viewer uses 5 MiB). */
+export declare const MEMORY_FILE_PREVIEW_LIMIT: number;
+/** One stored memory record (snake_case columns camelCased). */
+export interface MemoryRecord {
+    workspaceId: string;
+    id: string;
+    type: "user" | "feedback" | "reference";
+    title: string;
+    description: string;
+    body: string;
+    status: "active" | "quarantined" | "archived";
+    /** Origin session id, `null` for imports. */
+    sourceSession: string | null;
+    /** Trajectory seq range the fact came from ("820-831"), `null` when unknown. */
+    sourceSeqs: string | null;
+    /** The extraction run that wrote it; `'explicit'` for tool writes. */
+    sourceRun: string | null;
+    createdAt: string;
+    updatedAt: string;
+}
+/** One ledger row (audit + rollback via embedded before/after snapshots). */
+export interface LedgerEntry {
+    runId?: string | undefined;
+    sessionId?: string | undefined;
+    workspaceId?: string | undefined;
+    trigger: "turn-debounce" | "compaction" | "close-drain" | "explicit" | "import";
+    decision?: string | undefined;
+    skipReason?: string | undefined;
+    status?: string | undefined;
+    durationMs?: number | undefined;
+    model?: string | undefined;
+    usage?: unknown;
+    /** Applied/attempted mutations: `{id, action, before?, after?, sourceSeqs}`. */
+    files?: unknown;
+}
+/** Workspace rows the card's selector lists. */
+export interface WorkspaceSummary {
+    workspaceId: string;
+    activeCount: number;
+    updatedAt: string;
+}
+/** What a patrol pass found and did. */
+export interface PatrolResult {
+    ts: string;
+    /** Orphan FTS rows (no matching memory) removed. */
+    orphanFtsRows: number;
+    /** Records quarantined by the secret screen, with the redacted reasons. */
+    quarantined: {
+        workspaceId: string;
+        id: string;
+        reason: string;
+    }[];
+}
+/** The store surface every consumer (tool, extraction, card, injection) uses. */
+export interface MemoryStore {
+    readonly path: string;
+    get(workspaceId: string, id: string): MemoryRecord | undefined;
+    /** Active records, injection order: feedback > user > reference, then newest. */
+    list(workspaceId: string): MemoryRecord[];
+    /** Every non-archived record regardless of status (the card's projection). */
+    listAll(workspaceId: string): MemoryRecord[];
+    /**
+     * Keyword search, workspace-scoped: whitespace-separated tokens are
+     * AND-combined — trigram FTS when every token is ≥3 chars, literal LIKE
+     * substrings otherwise, and a LIKE fallback whenever FTS finds nothing.
+     */
+    search(workspaceId: string, query: string, limit?: number): MemoryRecord[];
+    /** The sole write gate: validate all proposals, apply atomically, ledger. */
+    applyProposals(ctx: ProposalContext, proposals: readonly MemoryProposal[]): ProposalOutcome[];
+    /** Ledger a run that produced no mutations (skips must be auditable too). */
+    logSkipped(entry: LedgerEntry): void;
+    cursor(workspaceId: string, sessionId: string): number | undefined;
+    setCursor(workspaceId: string, sessionId: string, seq: number): void;
+    state(workspaceId: string, key: string): string | undefined;
+    setState(workspaceId: string, key: string, value: string): void;
+    listWorkspaces(): WorkspaceSummary[];
+    /** Hygiene pass: orphan FTS cleanup + secret quarantine. */
+    patrol(): PatrolResult;
+    /** Ledger rows older than the cutoff, removed (the one unbounded table). */
+    pruneLedger(beforeIso: string): number;
+    close(): void;
+}
+/** Default database location: `$DSH_HOME/evolve/memory.db`, else `~/.dsh/…`. */
+export declare function defaultStorePath(): string;
+/** Open (creating on first use) the central store. */
+export declare function openMemoryStore(explicitPath?: string): Promise<MemoryStore>;
+//# sourceMappingURL=store.d.ts.map

package/lib/store.js

@@ -0,0 +1,241 @@
+/**
+ * The central SQLite memory store: one database file
+ * (`~/.dsh/evolve/memory.db`, rows partitioned by workspace path) holding
+ * every memory record, its FTS index, the extraction ledger, and per-session
+ * extraction cursors. The plugin's code is the literal sole writer — models
+ * propose, `applyProposals` gates and lands. See ADR
+ * `2026-10-06-sqlite-single-store`.
+ *
+ * Requires `node:sqlite` (Node ≥ 22.5; the desktop host's EnsureNode runtime
+ * guarantees v26). Unavailability is a typed error the entry point degrades
+ * on — injection and tooling switch off, the host keeps running.
+ */
+import { mkdirSync } from "node:fs";
+import { homedir } from "node:os";
+import { dirname, join, resolve } from "node:path";
+import { secretLeakReason } from "./memory-rules.js";
+import { applyProposals } from "./store-apply.js";
+/** Thrown when the runtime lacks `node:sqlite` — the degrade signal. */
+export class StoreUnavailableError extends Error {
+}
+/** State-table keys owned by the store (partitioned per workspace, `""` = global). */
+export const CURSOR_KEY_PREFIX = "seq:";
+export const PATROL_STATE_KEY = "patrol:last";
+export const MD_IMPORT_STATE_KEY = "md-imported";
+/** Global partition id for workspace-independent state rows. */
+export const GLOBAL_WORKSPACE = "";
+/** Preview size cap for the card's content endpoint (ZCode's viewer uses 5 MiB). */
+export const MEMORY_FILE_PREVIEW_LIMIT = 5 * 1024 * 1024;
+const DDL = `
+PRAGMA journal_mode=WAL;
+PRAGMA busy_timeout=5000;CREATE TABLE IF NOT EXISTS memories (
+  workspace_id TEXT NOT NULL,
+  id TEXT NOT NULL,
+  type TEXT NOT NULL CHECK (type IN ('user','feedback','reference')),
+  title TEXT NOT NULL,
+  description TEXT NOT NULL,
+  body TEXT NOT NULL CHECK (length(body) <= 65536),
+  status TEXT NOT NULL DEFAULT 'active'
+    CHECK (status IN ('active','quarantined','archived')),
+  source_session TEXT,
+  source_seqs TEXT,
+  source_run TEXT,
+  created_at TEXT NOT NULL,
+  updated_at TEXT NOT NULL,
+  PRIMARY KEY (workspace_id, id)
+) STRICT;
+CREATE INDEX IF NOT EXISTS idx_mem_ws_status ON memories(workspace_id, status);
+CREATE INDEX IF NOT EXISTS idx_mem_ws_updated ON memories(workspace_id, updated_at);
+CREATE VIRTUAL TABLE IF NOT EXISTS memories_fts USING fts5(
+  workspace_id, id, title, description, body, tokenize='trigram');
+-- FTS rows are synced in code by applyProposals (plain DELETE + INSERT), not
+-- by triggers: node:sqlite rejects the FTS5 'delete'-command INSERT that
+-- AFTER DELETE/UPDATE triggers would need (SQL logic error, verified on
+-- SQLite 3.53.4). The sole-writer design makes code-side sync reliable;
+-- patrol() reconciles any residue.
+CREATE TABLE IF NOT EXISTS extraction_log (
+  run_id TEXT, ts TEXT NOT NULL, session_id TEXT, workspace_id TEXT,
+  trigger TEXT CHECK (trigger IN ('turn-debounce','compaction','close-drain','explicit','import')),
+  decision TEXT, skip_reason TEXT,
+  status TEXT, duration_ms INTEGER, model TEXT, usage TEXT,
+  files TEXT
+);
+CREATE TABLE IF NOT EXISTS state (
+  workspace_id TEXT NOT NULL, key TEXT NOT NULL, value TEXT NOT NULL,
+  PRIMARY KEY (workspace_id, key)
+) STRICT;
+`;
+/** Default database location: `$DSH_HOME/evolve/memory.db`, else `~/.dsh/…`. */
+export function defaultStorePath() {
+    const home = process.env.DSH_HOME?.trim();
+    return resolve(home && home.length > 0 ? home : join(homedir(), ".dsh"), "evolve", "memory.db");
+}
+function recordOf(row) {
+    return {
+        workspaceId: row.workspace_id,
+        id: row.id,
+        type: row.type,
+        title: row.title,
+        description: row.description,
+        body: row.body,
+        status: row.status,
+        sourceSession: row.source_session,
+        sourceSeqs: row.source_seqs,
+        sourceRun: row.source_run,
+        createdAt: row.created_at,
+        updatedAt: row.updated_at,
+    };
+}
+const LIST_ORDER = "ORDER BY CASE type WHEN 'feedback' THEN 0 WHEN 'user' THEN 1 ELSE 2 END, updated_at DESC";
+/** Quote one token as an FTS5 phrase (trigram needs ≥3 chars to match). */
+function ftsPhrase(token) {
+    return `"${token.replaceAll('"', '""')}"`;
+}
+/**
+ * Split a query into keyword tokens on ASCII or full-width whitespace. Each
+ * token is matched on its own and AND-combined: trigram FTS can only match
+ * ≥3-char runs, so a keyword pair like `中文 交接` is unrepresentable as one
+ * FTS phrase and silently returns nothing under a phrase match.
+ */
+function queryTokens(query) {
+    return query.split(/[\s\u3000]+/).filter((token) => token.length > 0);
+}
+/** `%token%` with LIKE metacharacters escaped — keywords match literally. */
+function likePattern(token) {
+    return `%${token.replaceAll(/[\\%_]/g, "\\$&")}%`;
+}
+/** Open (creating on first use) the central store. */
+export async function openMemoryStore(explicitPath) {
+    const path = explicitPath === undefined ? defaultStorePath() : resolve(explicitPath);
+    let database;
+    try {
+        const { DatabaseSync } = await import("node:sqlite");
+        // The parent directory must exist before SQLite opens the file — a
+        // fresh `~/.dsh` has no `evolve/` yet.
+        mkdirSync(dirname(path), { recursive: true });
+        database = new DatabaseSync(path);
+    }
+    catch (error) {
+        throw new StoreUnavailableError(`node:sqlite unavailable (Node ≥ 22.5 required) — memory store disabled: ${error instanceof Error ? error.message : String(error)}`);
+    }
+    database.exec(DDL);
+    const stmts = {
+        get: database.prepare("SELECT * FROM memories WHERE workspace_id = ? AND id = ?"),
+        list: database.prepare(`SELECT * FROM memories WHERE workspace_id = ? AND status = 'active' ${LIST_ORDER}`),
+        listAll: database.prepare(`SELECT * FROM memories WHERE workspace_id = ? AND status != 'archived' ${LIST_ORDER}`),
+        fts: database.prepare(`SELECT m.* FROM memories m WHERE (m.workspace_id, m.id) IN (
+				 SELECT workspace_id, id FROM memories_fts WHERE memories_fts MATCH ? AND workspace_id = ?
+				) AND m.status = 'active' ${LIST_ORDER} LIMIT ?`),
+        stateGet: database.prepare("SELECT value FROM state WHERE workspace_id = ? AND key = ?"),
+        stateSet: database.prepare("INSERT INTO state (workspace_id, key, value) VALUES (?, ?, ?) " +
+            "ON CONFLICT (workspace_id, key) DO UPDATE SET value = excluded.value"),
+        cursorGet: database.prepare("SELECT CAST(value AS INTEGER) AS seq FROM state WHERE workspace_id = ? AND key = ?"),
+        workspaces: database.prepare("SELECT workspace_id, COUNT(*) AS n, MAX(updated_at) AS u FROM memories WHERE status = 'active' GROUP BY workspace_id ORDER BY u DESC"),
+        ledger: database.prepare("INSERT INTO extraction_log (run_id, ts, session_id, workspace_id, trigger, decision, skip_reason, status, duration_ms, model, usage, files) " +
+            "VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)"),
+        prune: database.prepare("DELETE FROM extraction_log WHERE ts < ?"),
+        ftsOrphans: database.prepare("SELECT f.rowid AS rid FROM memories_fts f LEFT JOIN memories m ON m.workspace_id = f.workspace_id AND m.id = f.id WHERE m.id IS NULL"),
+        ftsDrop: database.prepare("DELETE FROM memories_fts WHERE rowid = ?"),
+        activeRows: database.prepare("SELECT * FROM memories WHERE status = 'active'"),
+        quarantine: database.prepare("UPDATE memories SET status = 'quarantined' WHERE workspace_id = ? AND id = ?"),
+    };
+    // LIKE fallback: one OR-triplet per token, every token required. Statements
+    // are cached by token count — the query set repeats, the counts don't grow.
+    const likeStmts = new Map();
+    const likeSearch = (workspaceId, tokens, limit) => {
+        let stmt = likeStmts.get(tokens.length);
+        if (stmt === undefined) {
+            const clause = tokens
+                .map(() => "(title LIKE ? ESCAPE '\\' OR description LIKE ? ESCAPE '\\' OR body LIKE ? ESCAPE '\\')")
+                .join(" AND ");
+            stmt = database.prepare(`SELECT * FROM memories WHERE workspace_id = ? AND status = 'active' AND ${clause} ${LIST_ORDER} LIMIT ?`);
+            likeStmts.set(tokens.length, stmt);
+        }
+        const patterns = tokens.flatMap((token) => {
+            const pattern = likePattern(token);
+            return [pattern, pattern, pattern];
+        });
+        return stmt.all(workspaceId, ...patterns, limit).map(recordOf);
+    };
+    const store = {
+        path,
+        get(workspaceId, id) {
+            const row = stmts.get.get(workspaceId, id);
+            return row === undefined ? undefined : recordOf(row);
+        },
+        list(workspaceId) {
+            return stmts.list.all(workspaceId).map(recordOf);
+        },
+        listAll(workspaceId) {
+            return stmts.listAll.all(workspaceId).map(recordOf);
+        },
+        search(workspaceId, query, limit = 20) {
+            const tokens = queryTokens(query);
+            if (tokens.length === 0) {
+                return [];
+            }
+            if (tokens.every((token) => token.length >= 3)) {
+                const hits = stmts.fts.all(tokens.map(ftsPhrase).join(" AND "), workspaceId, limit);
+                if (hits.length > 0) {
+                    return hits.map(recordOf);
+                }
+            }
+            return likeSearch(workspaceId, tokens, limit);
+        },
+        applyProposals(ctx, proposals) {
+            return applyProposals({ database, now: () => new Date().toISOString() }, ctx, proposals).outcomes;
+        },
+        logSkipped(entry) {
+            writeLedger(stmts.ledger, entry);
+        },
+        cursor(workspaceId, sessionId) {
+            const row = stmts.cursorGet.get(workspaceId, CURSOR_KEY_PREFIX + sessionId);
+            return row?.seq === null || row === undefined ? undefined : row.seq;
+        },
+        setCursor(workspaceId, sessionId, seq) {
+            stmts.stateSet.run(workspaceId, CURSOR_KEY_PREFIX + sessionId, String(seq));
+        },
+        state(workspaceId, key) {
+            const row = stmts.stateGet.get(workspaceId, key);
+            return row?.value;
+        },
+        setState(workspaceId, key, value) {
+            stmts.stateSet.run(workspaceId, key, value);
+        },
+        listWorkspaces() {
+            return stmts.workspaces.all().map((row) => ({
+                workspaceId: row.workspace_id,
+                activeCount: row.n,
+                updatedAt: row.u,
+            }));
+        },
+        patrol() {
+            const result = { ts: new Date().toISOString(), orphanFtsRows: 0, quarantined: [] };
+            for (const row of stmts.ftsOrphans.all()) {
+                stmts.ftsDrop.run(row.rid);
+                result.orphanFtsRows += 1;
+            }
+            for (const row of stmts.activeRows.all()) {
+                const reason = secretLeakReason(`${row.title}\n${row.description}\n${row.body}`);
+                if (reason !== undefined) {
+                    stmts.quarantine.run(row.workspace_id, row.id);
+                    result.quarantined.push({ workspaceId: row.workspace_id, id: row.id, reason });
+                }
+            }
+            stmts.stateSet.run(GLOBAL_WORKSPACE, PATROL_STATE_KEY, JSON.stringify(result));
+            return result;
+        },
+        pruneLedger(beforeIso) {
+            return Number(stmts.prune.run(beforeIso).changes);
+        },
+        close() {
+            database.close();
+        },
+    };
+    return store;
+}
+/** JSON-encode the optional ledger fields and insert the row (never throws past a warn). */
+function writeLedger(stmt, entry) {
+    stmt.run(entry.runId ?? null, new Date().toISOString(), entry.sessionId ?? null, entry.workspaceId ?? null, entry.trigger, entry.decision ?? null, entry.skipReason ?? null, entry.status ?? null, entry.durationMs ?? null, entry.model ?? null, entry.usage === undefined ? null : JSON.stringify(entry.usage), entry.files === undefined ? null : JSON.stringify(entry.files));
+}
+//# sourceMappingURL=store.js.map

package/locale/en.json

@@ -1,6 +1,6 @@
 {
   "meta": {
     "title": "Workspace Memory",
-    "description": "Per-workspace markdown memory store with session-start index injection."
+    "description": "Central SQLite memory store partitioned by workspace: session-start index injection, gated explicit writes and proposal-based extraction."
   }
 }

package/locale/zh.json

@@ -1,6 +1,6 @@
 {
   "meta": {
     "title": "工作区记忆",
-    "description": "每个工作区一个 markdown 记忆库，会话开局注入索引，模型原生读写。"
+    "description": "中央 SQLite 记忆库，按工作区分区：开局注入索引、显式写入与提案制提取全部过代码门禁。"
   }
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "dsh-continual-evolve",
-  "version": "0.14.2",
-  "description": "ZCode-style workspace memory for DeepSeek Harness: a per-workspace markdown store with session-start index injection.",
+  "version": "0.15.1",
+  "description": "ZCode-style workspace memory for DeepSeek Harness: one central SQLite store partitioned by workspace, index injection, and sole-writer gated writes.",
   "license": "MIT",
   "repository": {
     "type": "git",
@@ -53,18 +53,20 @@
     "access": "public"
   },
   "scripts": {
-    "build": "tsc -p tsconfig.json",
-    "prepare": "tsc -p tsconfig.json",
+    "build": "npm run clean && tsc -p tsconfig.json",
+    "prepare": "npm run build",
+    "prepack": "npm run build && npm run check:pack",
     "dev": "tsc -p tsconfig.json --watch",
     "typecheck": "tsc -p tsconfig.json --noEmit && tsc -p tsconfig.scripts.json --noEmit",
     "test": "vitest run",
     "test:coverage": "vitest run --coverage",
     "test:watch": "vitest",
     "lint": "oxlint src test client",
-    "clean": "rm -rf lib",
+    "clean": "node -e \"require('node:fs').rmSync('lib',{recursive:true,force:true})\"",
     "check:docs": "tsx scripts/run-gates.ts docs",
     "check:handoff": "tsx scripts/verify-handoff-structure.ts --self-test && tsx scripts/verify-handoff-structure.ts",
-    "check:governance": "tsx scripts/verify-governance.ts"
+    "check:governance": "tsx scripts/verify-governance.ts",
+    "check:pack": "tsx scripts/verify-pack-contents.ts"
   },
   "peerDependencies": {
     "@deepseek-ai/schemastery": "^3.18.1"

package/lib/known-workspaces.d.ts

@@ -1,22 +0,0 @@
-/** One known workspace: the resolved root and when it was last served. */
-export interface KnownWorkspace {
-    root: string;
-    /** ISO timestamp of the most recent section assembly seen for this root. */
-    lastSeen: string;
-}
-/** The allowlist the card routes read through. */
-export interface KnownWorkspaces {
-    /**
-     * Record (or refresh) a workspace root. A relative or blank cwd is a
-     * silent no-op — the caller is the injection path, where a bad cwd
-     * already renders an empty section and must not turn into a throw.
-     */
-    remember(cwd: string): void;
-    /** Known roots, most recently served first. */
-    list(): KnownWorkspace[];
-}
-/** How many recent workspaces the card tracks. */
-export declare const DEFAULT_KNOWN_WORKSPACE_LIMIT = 8;
-/** Create the in-memory allowlist; `limit` is the LRU bound. */
-export declare function createKnownWorkspaces(limit?: number): KnownWorkspaces;
-//# sourceMappingURL=known-workspaces.d.ts.map

package/lib/known-workspaces.js

@@ -1,42 +0,0 @@
-/**
- * The workspace roots the card may look at, in memory only.
- *
- * Populated as a side effect of section assembly (the plugin already knows
- * each session's cwd there), this list is the card's read allowlist: the
- * memory API refuses any root the running process has not served a session
- * in, so the endpoint cannot be used to probe the filesystem. Bounded LRU,
- * never persisted — a restart starts empty and one session in a workspace
- * puts it back. No second store on disk.
- */
-import { isAbsolute, resolve } from "node:path";
-/** How many recent workspaces the card tracks. */
-export const DEFAULT_KNOWN_WORKSPACE_LIMIT = 8;
-/** Create the in-memory allowlist; `limit` is the LRU bound. */
-export function createKnownWorkspaces(limit = DEFAULT_KNOWN_WORKSPACE_LIMIT) {
-    const max = Math.max(1, limit);
-    // Insertion order encodes recency: the most recently served root is last.
-    const recent = new Map();
-    return {
-        remember(cwd) {
-            const trimmed = cwd.trim();
-            if (trimmed.length === 0 || !isAbsolute(trimmed)) {
-                return;
-            }
-            recent.delete(resolve(trimmed));
-            recent.set(resolve(trimmed), new Date().toISOString());
-            while (recent.size > max) {
-                const oldest = recent.keys().next();
-                if (oldest.done === true) {
-                    break;
-                }
-                recent.delete(oldest.value);
-            }
-        },
-        list() {
-            return [...recent.entries()]
-                .reverse()
-                .map(([root, lastSeen]) => ({ root, lastSeen }));
-        },
-    };
-}
-//# sourceMappingURL=known-workspaces.js.map

package/lib/workspace-catalog.d.ts

@@ -1,30 +0,0 @@
-import type { KnownWorkspaces } from "./known-workspaces.js";
-/** One workspace the card knows: canonical root plus its display label. */
-export interface CatalogEntry {
-    root: string;
-    /** Display title from the registry, else the directory name. */
-    label: string;
-}
-/** The read fence (`known`) and the listed set (`list`). */
-export interface WorkspaceCatalog {
-    /** Every workspace the card may read, in registry order. */
-    known(): CatalogEntry[];
-    /** The known workspaces that currently have a memory directory. */
-    list(): CatalogEntry[];
-}
-/** The slice of `ctx.workspaceRegistry` this plugin consumes. */
-export interface WorkspaceRegistryLike {
-    list(): unknown;
-}
-/** Where the catalog gets its workspace records, in precedence order. */
-export interface WorkspaceCatalogOptions {
-    /** Live registry lookup; undefined when the host exposes no registry. */
-    registry?: (() => WorkspaceRegistryLike | undefined) | undefined;
-    /** The roots this process served — the last-resort source. */
-    served: KnownWorkspaces;
-    /** Harness home; enables the `storages/workspace.json` fallback when set. */
-    homeDir?: string | undefined;
-}
-/** Create the catalog over the given sources. */
-export declare function createWorkspaceCatalog(options: WorkspaceCatalogOptions): WorkspaceCatalog;
-//# sourceMappingURL=workspace-catalog.d.ts.map