@staix/vault-mem 0.2.3 → 0.3.0

package/src/setup.ts

@@ -1,4 +1,4 @@
-import { closeSync, constants, fsyncSync, lstatSync, mkdirSync, openSync, readFileSync, realpathSync, renameSync, statSync, unlinkSync, writeFileSync } from "node:fs";
+import { chmodSync, closeSync, constants, fstatSync, fsyncSync, lstatSync, mkdirSync, openSync, readFileSync, readSync, realpathSync, renameSync, statSync, unlinkSync, writeFileSync } from "node:fs";
 import { homedir } from "node:os";
 import { dirname, isAbsolute, join, resolve } from "node:path";
 import { createHash, randomUUID } from "node:crypto";
@@ -14,7 +14,9 @@ const MAX_HOST_CONFIG = 4 * 1024 * 1024;
 export interface McpEntry { command: string; args: string[] }
 interface HostFile { target: SetupTarget; file: string; format: "json" | "toml"; key: string }
 export interface SetupAction { target: SetupTarget; file: string; change: "add" | "replace" | "unchanged" | "restore" | "remove" | "refused" | "none"; reason?: string }
-export interface SetupReport { mode: SetupMode; applied: boolean; entry: McpEntry; actions: SetupAction[]; notes: string[] }
+export interface ConsoleAction { file: string; module: string; change: "add" | "replace" | "unchanged" | "remove" | "none" | "refused"; reason?: string }
+export interface SetupReport { mode: SetupMode; applied: boolean; entry: McpEntry; root?: InstallRoot; actions: SetupAction[]; console?: ConsoleAction; notes: string[] }
+export interface InstallRoot { path: string; version: string }
 interface Receipt { version: 1; target: SetupTarget; file: string; existed: boolean; keyExisted?: boolean; prior: unknown; priorToml?: string[]; installed: McpEntry }
 
 function hosts(env: NodeJS.ProcessEnv, cwd: string): Record<SetupTarget, HostFile> {
@@ -36,12 +38,27 @@ function hosts(env: NodeJS.ProcessEnv, cwd: string): Record<SetupTarget, HostFil
     agy: { target: "agy", file: join(resolve(cwd), ".agents", "mcp_config.json"), format: "json", key: "mcpServers" },
   };
 }
-function readText(file: string): string | null {
-  let stat;
-  try { stat = lstatSync(file); } catch (error) { if ((error as NodeJS.ErrnoException).code === "ENOENT") return null; throw error; }
-  if (!stat.isFile()) throw new Error(`${file}: expected a plain file (links are refused)`);
-  if (stat.size > MAX_HOST_CONFIG) throw new Error(`${file}: exceeds 4 MiB`);
-  return readFileSync(file, "utf8");
+const MAX_PACKAGE_JSON = 64 * 1024;
+/** Bounded plain-file read on one descriptor: links, FIFOs and other non-regular files are refused, never read. */
+function readText(file: string, max = MAX_HOST_CONFIG): string | null {
+  let fd: number;
+  try { fd = openSync(file, constants.O_RDONLY | constants.O_NOFOLLOW | constants.O_NONBLOCK); }
+  catch (error) {
+    const code = (error as NodeJS.ErrnoException).code;
+    if (code === "ENOENT") return null;
+    if (code === "ELOOP") throw new Error(`${file}: expected a plain file (links are refused)`);
+    throw error;
+  }
+  try {
+    const stat = fstatSync(fd), limit = max >= 1024 * 1024 ? `${max / 1024 / 1024} MiB` : `${max / 1024} KiB`;
+    if (!stat.isFile()) throw new Error(`${file}: expected a plain file (links are refused)`);
+    if (stat.size > max) throw new Error(`${file}: exceeds ${limit}`);
+    const buffer = Buffer.alloc(max + 1);
+    let size = 0, n: number;
+    while (size < buffer.length && (n = readSync(fd, buffer, size, buffer.length - size, null)) > 0) size += n;
+    if (size > max) throw new Error(`${file}: exceeds ${limit}`);
+    return buffer.subarray(0, size).toString("utf8");
+  } finally { closeSync(fd); }
 }
 function atomicWrite(file: string, text: string | null): void {
   if (text === null) { unlinkSync(file); return; }
@@ -154,23 +171,44 @@ export function stableRuntime(execPath: string = process.execPath, onPath: strin
   if (!onPath || !isAbsolute(onPath)) return execPath;
   try { return realpathSync(onPath) === realpathSync(execPath) ? onPath : execPath; } catch { return execPath; }
 }
-export function defaultEntry(): McpEntry {
-  return { command: stableRuntime(), args: ["--smol", fileURLToPath(new URL("../bin/vmem.js", import.meta.url)), "mcp"] };
+/** The root of the running install: the directory that holds `bin/`, `src/` and `package.json`. */
+const OWN_ROOT = fileURLToPath(new URL("..", import.meta.url));
+export function defaultEntry(root: string = OWN_ROOT): McpEntry {
+  return { command: stableRuntime(), args: ["--smol", join(root, "bin", "vmem.js"), "mcp"] };
+}
+/**
+ * A vault-mem install root to register, such as `<install>/releases/<version>/`. It is resolved to its real
+ * path, so a `current` link registers the release it names and an upgrade beside it never changes what running
+ * hosts load.
+ */
+export function installRoot(root: string): InstallRoot {
+  if (!isAbsolute(root)) throw new Error("setup: --root must be an absolute path");
+  let path: string, text: string | null, pkg: { name?: unknown; version?: unknown };
+  try { path = realpathSync(root); text = readText(join(path, "package.json"), MAX_PACKAGE_JSON); }
+  catch (error) { throw new Error(`setup: ${root}: package.json is not readable (${error instanceof Error ? error.message : "read failed"})`); }
+  if (text === null) throw new Error(`setup: ${root} has no package.json`);
+  try { pkg = JSON.parse(text); } catch { throw new Error(`setup: ${root}: package.json is not valid JSON`); }
+  if (!pkg || typeof pkg !== "object") throw new Error(`setup: ${root} is not a vault-mem install root`);
+  if (pkg.name !== "@staix/vault-mem" || typeof pkg.version !== "string") throw new Error(`setup: ${root} is not a vault-mem install root`);
+  try { if (!statSync(join(path, "bin", "vmem.js")).isFile()) throw new Error(); }
+  catch { throw new Error(`setup: ${root} has no bin/vmem.js`); }
+  return { path, version: pkg.version };
 }
 /**
  * Plan, apply or undo vmem MCP registration. Dry-run writes nothing. Apply is idempotent, edits only
  * the `vmem` server entry and records the prior value. Undo restores that prior value only while the
  * entry is still the one setup installed; a later user edit is left alone and reported as refused.
  */
-export function runSetup(target: string, mode: SetupMode, options: { home: string; env?: NodeJS.ProcessEnv; cwd?: string; entry?: McpEntry }): SetupReport {
-  const env = options.env ?? process.env, entry = options.entry ?? defaultEntry();
+export function runSetup(target: string, mode: SetupMode, options: { home: string; env?: NodeJS.ProcessEnv; cwd?: string; entry?: McpEntry; root?: string }): SetupReport {
+  const env = options.env ?? process.env, root = options.root === undefined ? undefined : installRoot(options.root);
+  const entry = options.entry ?? defaultEntry(root?.path);
   if (target !== "all" && !(SETUP_TARGETS as readonly string[]).includes(target)) throw new Error(`setup: unknown target ${target}; use ${SETUP_TARGETS.join("|")}|all`);
   if (!isAbsolute(entry.command) || entry.args.some(arg => arg.includes("\0"))) throw new Error("setup: MCP command must be absolute");
   const table = hosts(env, options.cwd ?? process.cwd());
   const targets = target === "all" ? SETUP_TARGETS.filter(t => t !== "agy") : [target as SetupTarget];
-  const report: SetupReport = { mode, applied: false, entry, actions: [], notes: [
+  const report: SetupReport = { mode, applied: false, entry, ...(root ? { root } : {}), actions: [], notes: [
     "Registers the stdio server `vmem mcp`; restart the host session to load it.",
-    "No console plugin manifest is written: vmem ships no console plugin yet.",
+    "Writes the acon console plugin manifest ($AGENTHUB_HOME/console/plugins/vmem.json); re-run setup after upgrading vmem.",
   ] };
   if (target === "all") report.notes.push("`all` covers user-level hosts; run `vmem setup agy` inside a workspace for Antigravity.");
   for (const name of targets) {
@@ -214,6 +252,47 @@ export function runSetup(target: string, mode: SetupMode, options: { home: strin
       action.change = "refused"; action.reason = error instanceof Error ? error.message : "setup failed";
     }
   }
-  report.applied = mode !== "dry-run" && report.actions.some(a => !["none", "unchanged", "refused"].includes(a.change));
+  report.console = consoleManifest(mode, env, root?.path);
+  report.applied = mode !== "dry-run" && [...report.actions, report.console].some(a => !["none", "unchanged", "refused"].includes(a.change));
   return report;
 }
+
+/** The acon plugin manifest: `{api, tool, module, sha256}` in the family home, dir 0700 and file 0600 as acon requires. */
+export function consoleManifest(mode: SetupMode, env: NodeJS.ProcessEnv = process.env, root: string = OWN_ROOT): ConsoleAction {
+  const family = env.AGENTHUB_HOME?.trim() ? resolve(env.AGENTHUB_HOME) : join(env.HOME?.trim() || homedir(), ".agenthub");
+  const dir = join(family, "console", "plugins"), file = join(dir, "vmem.json");
+  const module = join(root, "src", "ui", "plugin.ts");
+  const action: ConsoleAction = { file, module, change: "none" };
+  try {
+    const next = { api: 1, tool: "vmem", module, sha256: createHash("sha256").update(readFileSync(module)).digest("hex") };
+    // Apply acon's own loader rules (agent-console scanPlugins): the directory and manifest must be real, owned by you
+    // and not writable by others. Kinds and owners are refused here; modes are fixed on apply.
+    for (const [path, kind] of [[dir, "directory"], [file, "file"]] as const) {
+      let info;
+      try { info = lstatSync(path); } catch { continue; }
+      if (kind === "directory" ? !info.isDirectory() : !info.isFile()) throw new Error(`${path}: acon needs a real ${kind}, not a link or other entry`);
+      if (typeof process.getuid === "function" && info.uid !== process.getuid()) throw new Error(`${path}: owned by another user; acon refuses it`);
+    }
+    const text = readText(file);
+    const current = text === null ? undefined : JSON.parse(text) as Record<string, unknown>;
+    if (mode === "undo") {
+      if (!current) { action.reason = "no manifest"; return action; }
+      if (current.module !== module) { action.change = "refused"; action.reason = "manifest points at another vmem install; left as is"; return action; }
+      unlinkSync(file); action.change = "remove"; return action;
+    }
+    const loose = (path: string, want: number) => { try { return (lstatSync(path).mode & 0o777) !== want; } catch { return false; } };
+    const modesOk = !loose(dir, 0o700) && !loose(file, 0o600);
+    if (isDeepStrictEqual(current, next) && modesOk) { action.change = "unchanged"; return action; }
+    action.change = current ? "replace" : "add";
+    if (!modesOk) action.reason = "permissions: plugin directory 0700, manifest 0600";
+    if (mode === "apply") {
+      mkdirSync(dir, { recursive: true, mode: 0o700 });
+      chmodSync(dir, 0o700);
+      atomicWrite(file, JSON.stringify(next, null, 2) + "\n");
+      chmodSync(file, 0o600);
+    }
+  } catch (error) {
+    action.change = "refused"; action.reason = error instanceof Error ? error.message : "manifest write failed";
+  }
+  return action;
+}

package/src/skills-mine.ts

@@ -1,3 +1,4 @@
+import { localDate } from "./local-date.ts";
 import { createHash } from "node:crypto";
 import { lstatSync, readdirSync } from "node:fs";
 import { join } from "node:path";
@@ -183,6 +184,7 @@ export function communityToCandidate(cid: number, members: readonly string[], gr
   let daySpan = 1, uniqueDays = 1;
   if (times.length >= 2) {
     daySpan = Math.max(1, Math.floor((times.at(-1)! - times[0]!) / DAY));
+    // Python `.date()` on an aware datetime keeps its own offset, so amem/vault `...Z` times count UTC days, as here.
     uniqueDays = new Set(times.map(t => new Date(t).toISOString().slice(0, 10))).size;
   }
   const membership = new Set(members), counts = new Map<string, number>();
@@ -446,7 +448,7 @@ export async function mineSkills(home: string, options: MineOptions): Promise<Mi
   const amem = await readAmemForMining({ env: options.env, since, ...(options.project ? { project: options.project } : {}), piiPatterns: local.config.piiPatterns ?? [] });
   return mineRecords({
     vault: options.vault, days, since, projects: amem.projects, records: [...amem.records, ...local.records], vocab, registry, skills, minSize, minNovelty, piiPatterns: local.config.piiPatterns ?? [],
-    today: now.toISOString().slice(0, 10), dropped: { policy: amem.screened, unreadable: amem.unreadable + local.unreadable, truncatedCapture: amem.truncatedCapture },
+    today: localDate(now), dropped: { policy: amem.screened, unreadable: amem.unreadable + local.unreadable, truncatedCapture: amem.truncatedCapture },
   });
 }
 

package/src/tidy.ts

@@ -4,6 +4,7 @@ import { hostname } from "node:os";
 import { join } from "node:path";
 import { isDeepStrictEqual } from "node:util";
 import type { VaultSpec, VmemConfig } from "./config.ts";
+import { unenforceablePii } from "./config.ts";
 import { emitFrontmatter, parseFrontmatter } from "./frontmatter.ts";
 import { extractLinks, normalizeTarget } from "./links.ts";
 import { isDenied } from "./platform.ts";
@@ -335,6 +336,8 @@ export function tidyVault(home: string, request: TidyRequest, options: { env?: N
   const config = loadRegistry(home), vault = config.vaults.find(v => v.id === request.vault);
   if (!vault) return { ...result, issues: [issue("V04", "unknown vault id")] };
   if (vault.write === "none" || (request.channel === "mcp" && vault.write !== "mcp")) return { ...result, issues: [issue("POLICY", "vault write policy refuses this channel")] };
+  const unenforceable = unenforceablePii(vault);
+  if (unenforceable) return { ...result, issues: [issue("PII_POLICY", unenforceable)] };
   const root = realpathSync(vault.path);
   if (root !== vault.path || isDenied(root, config.denyPaths)) return { ...result, issues: [issue("V06", "vault path denied or changed")] };
   // The LINT event must land in the vault this run read and wrote, even if the registry is changed meanwhile.

package/src/ui/panel.css

@@ -0,0 +1,16 @@
+.vmem { display: flex; flex-direction: column; gap: var(--acon-space-3); word-break: keep-all; }
+.vmem-bar { display: flex; flex-wrap: wrap; align-items: center; gap: var(--acon-space-2); }
+.vmem-inline { display: inline-flex; gap: var(--acon-space-2); }
+.vmem-input { min-height: 32px; min-width: 0; padding: 0 10px; border: 1px solid var(--acon-line-2); border-radius: var(--acon-radius-2); background: var(--acon-surface); color: var(--acon-text); font: inherit; }
+.vmem-bar input[type="search"] { flex: 1; max-width: 480px; }
+.vmem-head { display: flex; flex-wrap: wrap; align-items: center; gap: var(--acon-space-2); }
+.vmem-head h2 { margin: 0; font-size: 17px; }
+.vmem-sub { margin: 0; color: var(--acon-text-2); }
+.vmem-body { margin: var(--acon-space-2) 0 0; padding: var(--acon-space-3); max-height: 60vh; overflow: auto; white-space: pre-wrap; word-break: break-word; background: var(--acon-surface); border: 1px solid var(--acon-line); border-radius: var(--acon-radius-2); font: 13px/1.5 var(--acon-font-mono); }
+.vmem-mono { margin: 0; color: var(--acon-text-2); font: 12px var(--acon-font-mono); word-break: break-all; }
+.vmem details > summary { cursor: pointer; font-weight: 600; padding: var(--acon-space-1) 0; }
+@media (max-width: 600px) { .vmem-inline { width: 100%; } .vmem-inline .vmem-input { flex: 1; } }
+.vmem-form { display: flex; flex-direction: column; gap: var(--acon-space-2); max-width: 560px; }
+.vmem-form h2 { margin: 0; font-size: 15px; }
+.vmem-form .btn { align-self: flex-start; }
+.vmem-check { display: inline-flex; align-items: center; gap: 4px; color: var(--acon-text-2); }

package/src/ui/panel.js

@@ -0,0 +1,137 @@
+// vmem console panels (acon api 1). Runs under the shell's strict CSP: data is rendered as text only.
+const h = (tag, props = {}, ...kids) => {
+  const el = document.createElement(tag);
+  for (const [k, v] of Object.entries(props)) {
+    if (v === undefined || v === null || v === false) continue;
+    if (k === "text") el.textContent = String(v);
+    else if (k.startsWith("on")) el.addEventListener(k.slice(2), v);
+    else el.setAttribute(k, v === true ? "" : String(v));
+  }
+  el.append(...kids.flat().filter((k) => k !== null && k !== undefined && k !== false));
+  return el;
+};
+const empty = (title, hint) => h("div", { class: "empty" }, h("strong", { text: title }), hint ? h("span", { text: hint }) : null);
+const err = (text) => h("p", { class: "notice", role: "alert", text });
+const rows = (items, row) => (items.length ? h("ul", { class: "rows" }, items.map(row)) : null);
+const row = (title, sub, onOpen, ...verbs) => h("li", { class: "row" },
+  h("button", { type: "button", class: "row-main", onclick: onOpen },
+    h("span", { class: "row-text" }, h("span", { class: "row-title", text: title }), sub ? h("span", { class: "row-sub", text: sub }) : null)),
+  verbs.length ? h("span", { class: "row-verbs" }, verbs) : null);
+const btn = (label, onclick, cls = "btn") => h("button", { type: "button", class: cls, onclick, text: label });
+const chip = (text, tone) => h("span", { class: `chip${tone ? ` ${tone}` : ""}`, text });
+
+export default (host) => {
+  const root = h("div", { class: "vmem" });
+  host.mount.append(root);
+  let panel = "overview", params = {};
+  const go = (p, extra = {}) => host.navigate(host.tool, p, { ...(params.vault ? { vault: params.vault } : {}), ...extra });
+  const openNote = (path) => go("note", { path });
+
+  const searchForm = (q) => {
+    const input = h("input", { type: "search", name: "q", value: q ?? "", placeholder: "Search notes", "aria-label": "Search notes", class: "vmem-input" });
+    return h("form", { class: "vmem-bar", role: "search", onsubmit: (e) => { e.preventDefault(); go("notes", input.value.trim() ? { q: input.value.trim() } : {}); } },
+      input, h("button", { type: "submit", class: "btn", text: "Search" }));
+  };
+
+  const views = {
+    overview(s) {
+      const vaults = s.status?.vaults ?? [];
+      if (!vaults.length) return [empty("No vault registered", "Run `vmem vaults add <id> <path>` to register one.")];
+      return [
+        searchForm(""),
+        h("div", { class: "cards" },
+          h("section", { class: "card" }, h("h2", { text: "Vaults" }),
+            rows(vaults, (v) => row(v.id, `${v.kind} · write ${v.write}${v.health && v.health !== "ok" ? ` · ${v.health}` : ""}`, () => go("overview", { vault: v.id }), v.id === s.vault ? chip("shown", "accent") : null))),
+          h("section", { class: "card" }, h("h2", { text: `${s.noteCount ?? 0}${s.noteCountCapped ? "+" : ""} notes · maps` }),
+            rows((s.mocs ?? []).slice(0, 8), (m) => row(m.title || m.path, `${m.count} links`, () => openNote(m.path))) ?? empty("No maps yet")),
+          h("section", { class: "card" }, h("h2", { text: "Recent log" }),
+            rows(s.log ?? [], (r) => row(r.raw ?? `${r.type} ${r.source}${r.dest ? ` → ${r.dest}` : ""}`, r.raw ? "" : `${r.at} · ${r.project}${r.agent ? " · agent" : ""}`, () => go("log"))) ?? empty("Log is empty"))),
+      ];
+    },
+    notes(s) {
+      const list = s.notes ?? [];
+      return [searchForm(s.q), s.error ? err(s.error) : null,
+        rows(list, (n) => row(n.title || n.path, [n.type, n.domain, n.description].filter(Boolean).join(" · "), () => openNote(n.path)))
+          ?? empty(s.q ? "No notes match" : "No notes", s.q ? "Try fewer words; terms are combined with AND." : null)];
+    },
+    note(s) {
+      if (s.error) return [err(s.error)];
+      const n = s.note;
+      if (!n) return [empty("No note selected", "Open a note from Search or the palette.")];
+      const fm = n.frontmatter ?? {};
+      const title = fm.title || n.path;
+      const moveInput = h("input", { type: "text", name: "to", class: "vmem-input", "aria-label": "New stem", placeholder: "new-stem" });
+      const orgs = s.orgVaults ?? [];
+      const orgSelect = orgs.length ? h("select", { name: "org", class: "vmem-input", "aria-label": "Org vault" }, orgs.map((o) => h("option", { value: o, text: o }))) : null;
+      const out = s.links?.out ?? [], back = s.links?.in ?? [], dead = s.links?.dead ?? [];
+      return [
+        h("header", { class: "vmem-head" }, chip(fm.type || "note"), h("h2", { text: title }), fm.status ? chip(fm.status, fm.status === "superseded" ? "warn" : null) : null),
+        fm.description ? h("p", { class: "vmem-sub", text: fm.description }) : null,
+        h("div", { class: "vmem-bar" },
+          btn("Delete…", () => host.action({ action: "delete", path: n.path, ...(params.vault ? { vault: params.vault } : {}) }), "btn danger"),
+          h("form", { class: "vmem-inline", onsubmit: (e) => { e.preventDefault(); if (moveInput.value.trim()) host.action({ action: "move", from: n.path, to: moveInput.value.trim(), ...(params.vault ? { vault: params.vault } : {}) }); } },
+            moveInput, h("button", { type: "submit", class: "btn", text: "Move…" })),
+          orgSelect ? (() => {
+            const topics = h("input", { type: "text", name: "orgTopics", class: "vmem-input", "aria-label": "Org topics (comma separated, optional)", placeholder: "org topics (optional)" });
+            const again = h("input", { type: "checkbox", name: "again", "aria-label": "Promote again to another org" });
+            return h("form", { class: "vmem-inline", onsubmit: (e) => { e.preventDefault(); host.action({ action: "promote", path: n.path, to: orgSelect.value, ...(topics.value.trim() ? { topics: topics.value.trim() } : {}), ...(again.checked ? { again: true } : {}) }); } },
+              orgSelect, topics, h("label", { class: "vmem-check" }, again, h("span", { text: "again" })), h("button", { type: "submit", class: "btn", text: "Promote to org…" }));
+          })() : null),
+        h("details", { open: true }, h("summary", { text: "Body" }), h("pre", { class: "vmem-body", text: n.body ?? "" }), n.truncated ? err("Truncated; open the file for the rest.") : null),
+        h("details", {}, h("summary", { text: `Links (${out.length} out, ${back.length} in${dead.length ? `, ${dead.length} dead` : ""})` }),
+          rows([...out.map((l) => ({ path: l.resolved, label: `→ ${l.resolved}` })), ...back.map((l) => ({ path: l.source, label: `← ${l.source}` })), ...dead.map((l) => ({ label: `✕ ${l.target}` }))],
+            (l) => row(l.label, "", () => l.path && openNote(l.path))) ?? empty("No links")),
+        h("p", { class: "vmem-mono", text: `${n.path} · sha256 ${String(n.sha256 ?? "").slice(0, 12)}` }),
+      ];
+    },
+    promote(s) {
+      const projects = s.projects ?? [];
+      const all = projects.flatMap((p) => p.candidates);
+      const picked = all.find((c) => c.id === s.selected);
+      const field = (name, label, required) => h("input", { type: "text", name, class: "vmem-input", "aria-label": label, placeholder: label, required });
+      const form = picked ? (() => {
+        const domain = field("domain", "domain (required)", true), topics = field("topics", "topics, comma separated (required)", true), type = field("type", "type (optional)"), description = field("description", "description (optional)"), stem = field("stem", "file stem (needed when the title has no ASCII letters)");
+        return h("form", { class: "card vmem-form", onsubmit: (e) => {
+          e.preventDefault();
+          const meta = Object.fromEntries([["domain", domain], ["topics", topics], ["type", type], ["description", description], ["stem", stem]].filter(([, el]) => el.value.trim()).map(([k, el]) => [k, el.value.trim()]));
+          host.action({ action: "promote-from-amem", id: picked.id, project: picked.project, ...meta, ...(params.vault ? { vault: params.vault } : {}) });
+        } }, h("h2", { text: `Promote: ${picked.title || picked.kind}` }), domain, topics, type, description, stem, h("button", { type: "submit", class: "btn primary", text: "Preview promotion…" }));
+      })() : null;
+      return [s.unavailable ? err(s.unavailable) : null, form,
+        rows(all, (c) => row(c.title || c.kind, `${c.kind} · ${c.project} · ${new Date(c.at).toLocaleString()}`, () => go("promote", { id: c.id, project: c.project }),
+          s.selected === c.id ? chip("selected", "accent") : btn("Select", () => go("promote", { id: c.id, project: c.project }))))
+          ?? empty("No promotion candidates", "Durable agent memories appear here when agent-mem marks them for the vault.")];
+    },
+    lint(s) {
+      const f = s.findings ?? [];
+      return [h("p", { class: "vmem-sub", text: s.summary ?? "" }),
+        rows(f, (x) => row(x.message, `${x.code}${x.path ? ` · ${x.path}` : ""}`, () => x.path && openNote(x.path), chip(x.severity, x.severity === "error" ? "err" : "warn")))
+          ?? empty("No lint findings", "The vault passes every check.")];
+    },
+    log(s) {
+      const r = s.rows ?? [];
+      return [s.error ? err(s.error) : null,
+        rows(r, (x) => row(x.raw ?? `${x.type}  ${x.source}${x.dest ? ` → ${x.dest}` : ""}`, x.raw ? "unparsed line" : `${x.at} · ${x.project} · ${x.note}${x.agent ? " · agent" : ""}`,
+          () => { const p = x.dest ?? x.source; if (typeof p === "string" && p.startsWith("notes/")) openNote(p); })) ?? empty("Log is empty")];
+    },
+  };
+
+  let last = "";
+  host.onSnapshot((snap) => {
+    const sig = JSON.stringify([panel, snap]);
+    if (sig === last) return; // unchanged poll: keep focus and scroll
+    last = sig;
+    // A poll re-renders the view: carry every typed value and the focus over by field name.
+    // Rule: every form control in this file has a stable name, or its state is lost on the next poll.
+    const values = new Map([...root.querySelectorAll("input[name], select[name]")].map((el) => [el.name, el.type === "checkbox" ? el.checked : el.value]));
+    const focused = root.contains(document.activeElement) ? document.activeElement.getAttribute("name") : null;
+    root.replaceChildren(...(views[panel]?.(snap) ?? [empty("Unknown panel")]).filter(Boolean));
+    for (const el of root.querySelectorAll("input[name], select[name]")) if (values.has(el.name)) el[el.type === "checkbox" ? "checked" : "value"] = values.get(el.name);
+    if (focused) root.querySelector(`[name="${focused}"]`)?.focus();
+  });
+  return {
+    show(id, p = {}) { panel = id; params = p; last = ""; root.replaceChildren(); },
+    hide() {},
+    destroy() { root.remove(); },
+  };
+};