dsh-continual-evolve 0.14.2 → 0.15.0

package/lib/memory-section.d.ts

@@ -1,3 +1,4 @@
+import type { MemoryStore } from "./store.js";
 /** Name of the injected section (unique — duplicate names throw upstream). */
 export declare const MEMORY_SECTION_NAME = "evolve:memory-index";
 /** Default prompt-section order (empty 1–499 slot; upstream named slots start at 500). */
@@ -6,23 +7,14 @@ export declare const DEFAULT_MEMORY_SECTION_ORDER = 400;
 export declare const DEFAULT_MAX_CHARS = 6000;
 /** Sessions whose frozen section text is kept before LRU eviction. */
 export declare const DEFAULT_FROZEN_SESSIONS = 32;
-/** The assembling agent's validated absolute cwd, or undefined when absent. */
-export declare function cwdOf(agent: unknown): string | undefined;
-/** Absolute memory directory for a workspace root. */
-export declare function memoryDirFor(cwd: string): string;
-/**
- * Ensure `.evolve/` is ignored when the workspace is a git repository, so
- * the memory store never shows up in git status. Best-effort hygiene: a
- * non-git workspace (no `.git` entry at the cwd) is left untouched — no
- * `.gitignore` is created — and any write failure is swallowed.
- */
-export declare function ensureGitIgnored(cwd: string): void;
 /**
- * Ensure the store exists (creating the directory and a starter index on
- * first use), then return the trimmed index text. Any filesystem failure
- * degrades to "" — injection must never break an assembly.
+ * Legacy MD-era store location. Only the migration path (`import-md.ts`) and
+ * the not-yet-migrated card projection still resolve it; the injection path
+ * queries the central database.
  */
-export declare function readMemoryIndex(dir: string, bootstrap?: boolean): string;
+export declare function memoryDirFor(cwd: string): string;
+/** The assembling agent's validated absolute cwd, or undefined when absent. */
+export declare function cwdOf(agent: unknown): string | undefined;
 /** What fitting the index into the budget produced. */
 export interface IndexFit {
     /** Index text actually shown (possibly truncated to a line boundary). */
@@ -32,28 +24,36 @@ export interface IndexFit {
 }
 /**
  * Whole-line-preserving truncation of the index to `maxChars` characters.
- * Only index rows that fit whole are shown — a partial markdown row would
- * corrupt the line the model reads. When not even one row fits, `text` is
- * "" and `dropped` carries the full length.
+ * Only index rows that fit whole are shown — a partial row would corrupt the
+ * line the model reads. When not even one row fits, `text` is "" and
+ * `dropped` carries the full length.
  */
 export declare function fitIndex(index: string, maxChars: number): IndexFit;
+/** One index line: hook only — bodies are a `memory_read` call away. */
+export declare function indexLineOf(record: {
+    id: string;
+    title: string;
+    description: string;
+    type: string;
+}): string;
 /** Options for {@link memorySectionText}. */
 export interface MemorySectionOptions {
+    /** The opened store; undefined while it is still loading or failed. */
+    store: MemoryStore | undefined;
     /** Hard character budget for the injected index (default 6000). */
     maxChars?: number;
-    /** Include the when_to_save guide (default true). */
+    /** Include the when-to-save guide (default true). */
     guide?: boolean;
-    /** Skip store bootstrap (tests). */
-    bootstrap?: boolean;
+    /** Whether `memory_write`/`memory_read` are actually registered on this host. */
+    toolsAvailable?: boolean;
 }
 /**
- * Compose the full memory section for one assembling agent: the guide
- * wrapped around the budget-bounded index, with the absolute store path
- * handed out so the model can read and write the files directly. With the
- * guide off and an empty index the result is "" — the prompt renderer then
+ * Compose the full memory section for one assembling agent. Any store
+ * failure degrades to "" — injection must never break an assembly. With the
+ * guide off and an empty store the result is "" — the prompt renderer then
  * drops the section, so an empty workspace costs zero tokens.
  */
-export declare function memorySectionText(agent: unknown, opts?: MemorySectionOptions): string;
+export declare function memorySectionText(agent: unknown, opts: MemorySectionOptions): string;
 /** A per-session frozen view of the memory section text. */
 export interface FrozenMemorySection {
     /**

package/lib/memory-section.js

@@ -1,25 +1,21 @@
 /**
- * The whole runtime of the plugin after the 2026-10-04 ZCode-alignment
- * teardown: the session-start memory section.
+ * The session-start memory section: a store query rendered into the system
+ * prompt (the v0.15 SQLite single-store redesign, ADR
+ * `2026-10-06-sqlite-single-store`).
  *
- * The store is plain markdown inside the workspace — `<cwd>/.evolve/memory/`
- * with a `MEMORY.md` index and one file per fact — so the model reads and
- * writes it with its native file tools (DSH fences only out-of-workspace
- * writes; dot-directories inside the workspace pass both ways). This module
- * hands out the absolute path, injects the index content, and wraps the
- * when-to-save guide around it. There are no tools, no scopes, and no
- * governance: the files are the store, and a bad memory is a visible file
- * the user deletes.
+ * The injected index is a query result, not a file: one line per active
+ * memory of the assembling agent's workspace, feedback > user > reference,
+ * hooks only (title + description). Bodies live in the database and are
+ * fetched on demand with `memory_read`; there is no MEMORY.md to maintain
+ * and nothing for the model to write directly.
  *
  * Session-freeze contract (the prompt-cache guard): the section is computed
  * once per agent id and reused byte-for-byte afterwards, so the system
  * prompt stays stable within a session and cache reads keep hitting. A
- * memory written mid-session becomes visible in the NEXT session; the model
- * can always read the directory directly for the immediate need.
+ * memory written mid-session becomes visible in the NEXT session.
  */
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import { isAbsolute, join, resolve } from "node:path";
-import { MEMORY_GUIDE_RULES, memoryGuideIntro } from "./memory-guide.js";
+import { memoryGuideIntro, MEMORY_GUIDE_RULES } from "./memory-guide.js";
 /** Name of the injected section (unique — duplicate names throw upstream). */
 export const MEMORY_SECTION_NAME = "evolve:memory-index";
 /** Default prompt-section order (empty 1–499 slot; upstream named slots start at 500). */
@@ -28,12 +24,14 @@ export const DEFAULT_MEMORY_SECTION_ORDER = 400;
 export const DEFAULT_MAX_CHARS = 6000;
 /** Sessions whose frozen section text is kept before LRU eviction. */
 export const DEFAULT_FROZEN_SESSIONS = 32;
-const MEMORY_DIR_SEGMENTS = [".evolve", "memory"];
-const INDEX_FILE = "MEMORY.md";
-/** Starter index written on first use; the model maintains every line after. */
-const STARTER_INDEX = "# 记忆索引\n\n<!-- 一行一条：- [标题](文件名.md) — 一句话相关性钩子；写新记忆后在此追加一行 -->\n";
-/** Appended to the workspace .gitignore on bootstrap (git workspaces only). */
-const GITIGNORE_ENTRY = "# workspace memory (dsh-continual-evolve)\n.evolve/\n";
+/**
+ * Legacy MD-era store location. Only the migration path (`import-md.ts`) and
+ * the not-yet-migrated card projection still resolve it; the injection path
+ * queries the central database.
+ */
+export function memoryDirFor(cwd) {
+    return join(resolve(cwd), ".evolve", "memory");
+}
 /** The assembling agent's validated absolute cwd, or undefined when absent. */
 export function cwdOf(agent) {
     try {
@@ -52,56 +50,11 @@ export function cwdOf(agent) {
         return undefined;
     }
 }
-/** Absolute memory directory for a workspace root. */
-export function memoryDirFor(cwd) {
-    return join(resolve(cwd), ...MEMORY_DIR_SEGMENTS);
-}
-/**
- * Ensure `.evolve/` is ignored when the workspace is a git repository, so
- * the memory store never shows up in git status. Best-effort hygiene: a
- * non-git workspace (no `.git` entry at the cwd) is left untouched — no
- * `.gitignore` is created — and any write failure is swallowed.
- */
-export function ensureGitIgnored(cwd) {
-    try {
-        if (!existsSync(join(cwd, ".git"))) {
-            return;
-        }
-        const gitignore = join(cwd, ".gitignore");
-        const existing = existsSync(gitignore) ? readFileSync(gitignore, "utf8") : "";
-        if (existing.split("\n").some((line) => line.trim() === ".evolve/")) {
-            return;
-        }
-        const prefix = existing.length > 0 && !existing.endsWith("\n") ? "\n" : "";
-        writeFileSync(gitignore, `${existing}${prefix}${GITIGNORE_ENTRY}`, "utf8");
-    }
-    catch {
-        // Never blocks the store; worst case is a visible .evolve/ in git status.
-    }
-}
-/**
- * Ensure the store exists (creating the directory and a starter index on
- * first use), then return the trimmed index text. Any filesystem failure
- * degrades to "" — injection must never break an assembly.
- */
-export function readMemoryIndex(dir, bootstrap = true) {
-    try {
-        if (bootstrap && !existsSync(dir)) {
-            mkdirSync(dir, { recursive: true });
-            writeFileSync(join(dir, INDEX_FILE), STARTER_INDEX, "utf8");
-            ensureGitIgnored(resolve(dir, "..", ".."));
-        }
-        return readFileSync(join(dir, INDEX_FILE), "utf8").trim();
-    }
-    catch {
-        return "";
-    }
-}
 /**
  * Whole-line-preserving truncation of the index to `maxChars` characters.
- * Only index rows that fit whole are shown — a partial markdown row would
- * corrupt the line the model reads. When not even one row fits, `text` is
- * "" and `dropped` carries the full length.
+ * Only index rows that fit whole are shown — a partial row would corrupt the
+ * line the model reads. When not even one row fits, `text` is "" and
+ * `dropped` carries the full length.
  */
 export function fitIndex(index, maxChars) {
     const budget = Math.max(0, maxChars);
@@ -116,40 +69,53 @@ export function fitIndex(index, maxChars) {
     const text = cut.slice(0, lastLine);
     return { text, dropped: index.length - text.length };
 }
+/** One index line: hook only — bodies are a `memory_read` call away. */
+export function indexLineOf(record) {
+    return `- [${record.id}] ${record.title} — ${record.description}（${record.type}）`;
+}
 /**
- * Compose the full memory section for one assembling agent: the guide
- * wrapped around the budget-bounded index, with the absolute store path
- * handed out so the model can read and write the files directly. With the
- * guide off and an empty index the result is "" — the prompt renderer then
+ * Compose the full memory section for one assembling agent. Any store
+ * failure degrades to "" — injection must never break an assembly. With the
+ * guide off and an empty store the result is "" — the prompt renderer then
  * drops the section, so an empty workspace costs zero tokens.
  */
 export function memorySectionText(agent, opts) {
-    const guide = opts?.guide ?? true;
-    const maxChars = opts?.maxChars ?? DEFAULT_MAX_CHARS;
+    const guide = opts.guide ?? true;
+    const maxChars = opts.maxChars ?? DEFAULT_MAX_CHARS;
     const cwd = cwdOf(agent);
-    if (!cwd) {
+    if (!cwd || opts.store === undefined) {
+        return "";
+    }
+    let records;
+    try {
+        records = opts.store.list(cwd);
+    }
+    catch {
         return "";
     }
-    const dir = memoryDirFor(cwd);
-    const index = readMemoryIndex(dir, opts?.bootstrap ?? true);
+    const index = records.map(indexLineOf).join("\n");
     const { text, dropped } = fitIndex(index, maxChars);
     const parts = [];
-    if (index.length === 0) {
+    if (records.length === 0) {
         parts.push("<memories>\n（暂无记忆）\n</memories>");
     }
     else if (text.length > 0) {
         parts.push(`<memories>\n${text}\n</memories>`);
         if (dropped > 0) {
-            parts.push(`（索引超出 ${maxChars} 字符预算，已截断——其余记忆直接读取 \`${dir}/\` 目录）`);
+            parts.push(`（索引超出 ${maxChars} 字符预算，已截断——其余记忆用 \`memory_read\` 关键词检索）`);
         }
     }
     else {
-        parts.push(`（索引超出 ${maxChars} 字符预算，一行都放不下——记忆直接读取 \`${dir}/\` 目录）`);
+        parts.push(`（索引超出 ${maxChars} 字符预算，一行都放不下——记忆用 \`memory_read\` 关键词检索）`);
     }
     if (!guide) {
-        return index.length === 0 ? "" : parts.join("\n\n");
+        return records.length === 0 ? "" : parts.join("\n\n");
     }
-    return [memoryGuideIntro(dir), ...parts, MEMORY_GUIDE_RULES].join("\n\n");
+    return [
+        memoryGuideIntro(opts.store.path, cwd, opts.toolsAvailable ?? true),
+        ...parts,
+        MEMORY_GUIDE_RULES,
+    ].join("\n\n");
 }
 /**
  * Freeze the section text per agent id. The frozen value is what keeps the

package/lib/memory-snapshot.d.ts

@@ -1,82 +1,66 @@
-/** The index file name (same store contract as the injection path). */
-export declare const MEMORY_SNAPSHOT_INDEX_FILE = "MEMORY.md";
-/**
- * Preview size cap for the file content endpoint — files above it answer
- * `too-large` instead of their body (ZCode's memory viewer uses the same 5 MiB).
- */
-export declare const MEMORY_FILE_PREVIEW_LIMIT: number;
-/** One memory file with its frontmatter fields ("" when absent). */
+import { MEMORY_FILE_PREVIEW_LIMIT, type MemoryStore } from "./store.js";
+export { MEMORY_FILE_PREVIEW_LIMIT };
+/** One memory row the card renders. */
 export interface MemoryFileInfo {
-    file: string;
-    name: string;
+    id: string;
+    title: string;
     description: string;
     type: string;
-    /** File modification time in epoch milliseconds (the card's "updated" line). */
+    /** Row status; quarantined rows render in the patrol section, not here. */
+    status: string;
+    /** Update time in epoch milliseconds (the card's "updated" line). */
     updatedAt: number;
 }
-/** One parsed index row: `- [title](file.md) — hook`. */
-export interface MemoryIndexRow {
-    title: string;
-    file: string;
-}
 /** The full read-only snapshot the card renders for one workspace root. */
 export interface MemorySnapshot {
     root: string;
-    memoryDir: string;
     exists: boolean;
+    /** Set when the store query failed; null otherwise. */
+    readError: string | null;
+    /** Active row count (the number the card's stats line shows). */
     fileCount: number;
-    indexEntryCount: number;
+    /** Active rows (the list the card renders). */
     files: MemoryFileInfo[];
-    /** Index rows whose referenced file no longer exists on disk. */
-    missingFiles: string[];
-    /** .md files on disk that no index row references. */
-    unindexedFiles: string[];
-    /** Set when the store exists but could not be read; null otherwise. */
-    readError: string | null;
+    /** Rows quarantined by patrol — displayed as 巡检异常, never in the list. */
+    quarantined: {
+        id: string;
+        reason: string;
+    }[];
+    /** The last patrol pass this process recorded (null before the first). */
+    lastPatrol: {
+        ts: string;
+        orphanFtsRows: number;
+        quarantined: number;
+    } | null;
 }
-/** Minimal frontmatter fields the card shows. */
-export interface MemoryFrontmatter {
-    name: string;
-    description: string;
-    type: string;
-}
-/**
- * Parse `- [title](file.md) …` rows out of an index text. Anything else
- * (headings, the bootstrap hint comment, blank lines) is ignored.
- */
-export declare function parseMemoryIndexRows(indexText: string): MemoryIndexRow[];
 /**
- * Read the card-relevant frontmatter fields (`name`, `description`, `type`)
- * from a leading `---` block. A missing or malformed block yields "" fields —
- * the body text remains the source of truth the user opens in the editor.
+ * The read-only snapshot for one workspace partition. A workspace without
+ * rows reports `exists: false` (the card shows the empty state); a failing
+ * query reports `readError` instead of throwing — the card must observe,
+ * never break.
  */
-export declare function parseMemoryFrontmatter(text: string): MemoryFrontmatter;
-/**
- * The read-only memory snapshot for one workspace root. A missing store
- * reports `exists: false` (the card shows the empty state); a store that
- * exists but fails to read reports `readError` instead of throwing — the
- * card must observe, never break.
- */
-export declare function memorySnapshot(root: string): MemorySnapshot;
+export declare function memorySnapshot(store: MemoryStore, root: string): MemorySnapshot;
 /** The content endpoint's outcomes: the body, or why there is none. */
-export type MemoryFileContent = {
+export type MemoryEntryContent = {
     ok: true;
-    file: string;
+    id: string;
     content: string;
-    mtimeMs: number;
-    changed: boolean;
+    updatedAtMs: number;
 } | {
     ok: false;
-    reason: "outside" | "absent" | "too-large";
+    reason: "absent" | "too-large";
 };
 /**
- * Read one memory file's body for the card's content preview — the viewer
- * side of the same read-only fence as `memorySnapshot`. The requested file
- * name must be a plain entry of the workspace's memory directory (no path
- * separators, no traversal, resolved location stays inside the directory);
- * anything else answers `outside` without touching the filesystem, so the
- * endpoint cannot become a path oracle. Oversized files answer `too-large`
- * with the body unread.
+ * Read one memory record's body for the card's content preview — keyed by
+ * id, never by file name (the store is a database; there are no files to
+ * path-check). An unknown id answers `absent`; bodies are capped at 64KB by
+ * the schema, so `too-large` can only fire if the preview limit were ever
+ * lowered below that.
  */
-export declare function memoryFileContent(root: string, file: string): MemoryFileContent;
+export declare function memoryEntryContent(store: MemoryStore, root: string, id: string): MemoryEntryContent;
+/** The workspace rows the card lists: active partitions whose directory survives. */
+export declare function listCardWorkspaces(store: MemoryStore): {
+    root: string;
+    label: string;
+}[];
 //# sourceMappingURL=memory-snapshot.d.ts.map