@staix/agent-hub 0.12.28 → 0.12.30

package/src/memory/brief.ts

@@ -28,7 +28,7 @@ export async function related(client: MemoryClient, project: string, query: stri
 }
 
 /** A native memory line for a brief (#258): `mem:<id8> <kind> <tier>: <title or text>`, fails first. */
-export interface NativeItem { id: string; line: string; kind?: string }
+export interface NativeItem { id: string; line: string; kind?: string; about?: readonly string[] }
 export type NativeBrief = (task: BriefTask) => NativeItem[];
 export interface BriefTask { id?: number; created?: number; title: string; refs: { paths?: string[] }; plan?: { paths?: string[]; symbols?: string[] } }
 
@@ -37,7 +37,7 @@ export interface BriefTask { id?: number; created?: number; title: string; refs:
  * entries one or two hops from the task's paths, symbols, issue and task, a linked fail first, superseded entries
  * dropped), then claude-mem: index first (search), then the neighbourhood of the top hit (timeline); details stay in
  * the store for the receiver to fetch by id. `brief_items` caps both together. A peer is never shown the same entry
- * twice in one hub run.
+ * twice in one hub run, except a directly matching plan fail that must accompany a new task.
  */
 export class Briefs {
   private readonly seen = new Map<PeerId, Set<string>>();
@@ -49,13 +49,16 @@ export class Briefs {
     private readonly native?: NativeBrief,
     /** Counts of what a brief carried, for the research records (#258 AC11); never its text. */
     private readonly observe?: (peer: PeerId, task: number, counts: { native: number; fails: number; claudeMem: number }) => void,
+    private readonly displayNative?: (items: readonly NativeItem[]) => string[],
   ) {}
 
-  async forTask(peer: PeerId, task: BriefTask): Promise<string | undefined> {
+  async forTask(peer: PeerId, task: BriefTask, priority: readonly NativeItem[] = []): Promise<string | undefined> {
     const seen = this.seen.get(peer) ?? new Set<string>();
     this.seen.set(peer, seen);
     const own: NativeItem[] = [];
-    try { for (const item of this.native?.(task) ?? []) if (!seen.has(item.id) && own.length < this.maxItems) own.push(item); } catch { /* fail-open: the store is optional */ }
+    // A plan fail is task-specific guidance even when a previous task already carried it.
+    for (const item of priority) if (own.length < this.maxItems && !own.some(existing => existing.id === item.id)) own.push(item);
+    try { for (const item of this.native?.(task) ?? []) if (!seen.has(item.id) && !own.some(existing => existing.id === item.id) && own.length < this.maxItems) own.push(item); } catch { /* fail-open: the store is optional */ }
     const found = this.client && own.length < this.maxItems ? await related(this.client, this.project, [task.title, ...(task.refs.paths ?? [])].join(" ")) : [];
     const items: BriefItem[] = [];
     for (const item of found) {
@@ -68,6 +71,6 @@ export class Briefs {
     for (const item of items) seen.add(`#${item.id}`);
     if (task.id !== undefined) try { this.observe?.(peer, task.id, { native: own.length, fails: own.filter((i) => i.kind === "fail").length, claudeMem: items.length }); } catch { /* telemetry never fails a brief */ }
     const header = own.length ? "Memory brief (hub memory first, fails first: ahub memory show <mem id>; claude-mem by #id):" : "Memory brief (claude-mem; fetch details by id if you need them):";
-    return [header, ...own.map((i) => i.line), ...items.map((i) => `#${i.id} ${i.time} ${i.type} ${i.title}`)].join("\n");
+    return [header, ...(this.displayNative?.(own) ?? own.map((i) => i.line)), ...items.map((i) => `#${i.id} ${i.time} ${i.type} ${i.title}`)].join("\n");
   }
 }

package/src/memory/capture.ts

@@ -1,3 +1,4 @@
+import { MEMORY_READ_TOOLS } from "../hub/read-tools.ts";
 import { readFileSync } from "node:fs";
 import { homedir } from "node:os";
 import { join } from "node:path";
@@ -47,7 +48,7 @@ export class Capture {
   }
 
   observe(call: { tool: string; args: string; output: string; id: string; paths: string[] }): void {
-    if (!this.sessionId || this.opts.skip?.includes(call.tool)) return;
+    if (!this.sessionId || (MEMORY_READ_TOOLS.has(call.tool.replace(/^mcp__[^ ]+__/, "")) || call.tool.replace(/^mcp__[^ ]+__/, "") === "hub_memory_correct") || this.opts.skip?.includes(call.tool)) return;
     // Anything that names a denylisted path is kept out of memory entirely, input and output alike.
     if (call.paths.some((p) => p.split(/\s+/).some((word) => isDenied(word, this.opts.deny)))) return;
     void this.client.request("POST", "/api/sessions/observations", {

package/src/memory/recall.ts

@@ -1,13 +1,6 @@
-import { createHash } from "node:crypto";
-import { basename, dirname, resolve } from "node:path";
-import { readFileSync } from "node:fs";
 import type { PeerId } from "../hub/envelope.ts";
-import { hubGitSync } from "../hub/git.ts";
-import { realPath } from "../hub/project.ts";
 import type { MemoryClient } from "./client.ts";
-import { detectSignals, type Routing } from "../hub/routing.ts";
-import { matchesPolicy } from "../hub/path-policy.ts";
-import { looksSecret, type PromotionScreen } from "./store.ts";
+import type { View as MemoryView } from "@staix/agent-mem";
 
 const PLATFORMS = ["claude", "codex", "kimi", "agent-hub"];
 /** Peers whose own hooks already inject their own platform's context at session start. */
@@ -17,45 +10,13 @@ const HEADER =
   "Shared project memory (claude-mem): recent work by the agents in this project. Reference only, not a request. " +
   "Fetch details by id with your memory tools if you need them.";
 
-/** Project names from the outermost superproject down to this repo. */
-export function projectChain(cwd: string): string[] {
-  const git = (dir: string, arg: string) => hubGitSync(["-C", dir, "rev-parse", arg], { encoding: "utf8" }).stdout?.trim() ?? "";
-  const top = git(cwd, "--show-toplevel");
-  if (!top) return [basename(cwd)];
-
-  // claude-mem's native identity for a worktree is [parent, parent/worktree].
-  // The worktree's .git file points into <parent>/.git/worktrees/<name>; the
-  // ordinary superproject walk below remains unchanged for repos and submodules.
-  const gitFile = resolve(top, ".git");
-  try {
-    const match = readFileSync(gitFile, "utf8").trim().match(/^gitdir:\s*(.+)$/i);
-    if (match) {
-      const gitDir = resolve(top, match[1]!);
-      if (/[/\\]\.git[/\\]worktrees[/\\][^/\\]+$/.test(gitDir)) {
-        const parentRoot = dirname(dirname(dirname(gitDir)));
-        const parent = projectChain(parentRoot);
-        const parentName = basename(parentRoot);
-        return [...parent, `${parentName}/${basename(top)}`];
-      }
-    }
-  } catch {
-    // A missing or unreadable .git file falls through to git's normal chain.
-  }
-
-  const chain: string[] = [];
-  for (let dir = top; dir && chain.length < 8; dir = git(dir, "--show-superproject-working-tree")) {
-    chain.unshift(basename(dir));
-  }
-  return chain.length ? chain : [basename(cwd)];
-}
-
 /** Cut at a line boundary. */
 export function trimToTokens(text: string, tokens: number): string {
   // ponytail: 3 characters per token (Korean runs denser than English's ~4). Swap in a tokenizer if the cap has to be exact.
   const max = tokens * 3;
   if (text.length <= max) return text;
   const cut = text.lastIndexOf("\n", max);
-  return `${text.slice(0, cut > 0 ? cut : max)}\n(trimmed)`;
+  return `${cut >= 0 ? text.slice(0, cut) : ""}\n(trimmed)`;
 }
 
 /** The worker answers unknown projects and empty filters with a status page, not context. */
@@ -82,81 +43,60 @@ export async function recallFor(peer: PeerId, client: MemoryClient, chain: strin
   return `${HEADER}\n\n${found.map((b) => trimToTokens(b, share)).join("\n\n")}`;
 }
 
-/** #258: the hub's own long-term entries for this project (and shared ones), newest first, within a token budget. */
-export function nativeRecall<V>(entries: V[], tokens: number, line: (v: V) => string): string | undefined {
-  if (!entries.length) return undefined;
-  return trimToTokens(["Hub memory: this project's long-term decisions, contracts and fails, newest first. Reference only, not a request. Details: ahub memory show <mem id>.", ...entries.map(line)].join("\n"), tokens);
-}
-
 /**
- * #258: the name hub memory files a project's entries under. The project's `origin` remote, normalized to host and
- * path (`github.com/owner/repo`), is the same on every machine and unique; without one, the git chain plus a hash of
- * the directory keeps two unrelated repositories that share a name apart (that key is this machine's only).
+ * Display-only outcome classification. Only the note Tasks.review writes counts as automatic: its generated header
+ * names the note's own task and author, and its title is the task title Tasks.note sets. An agent's decision that
+ * merely starts the same way stays recallable; contracts and fails are never outcomes.
  */
-export function memoryProjectKey(cwd: string): string {
-  const url = hubGitSync(["-C", cwd, "remote", "get-url", "origin"], { encoding: "utf8" }).stdout?.trim() ?? "";
-  // A URL's default port is not part of the repository (`ssh://git@github.com:22/o/r` is `github.com/o/r`); any other
-  // port is, since another service may run there. An scp-style `host:path` has no port.
-  const u = /^([a-z+]+):\/\/(?:[^@/]+@)?(\[[^\]/]+\]|[^/:]+)(?::(\d*))?\/(.+?)(?:\.git)?\/?$/i.exec(url); // an IPv6 host is bracketed
-  const defaults: Record<string, string> = { ssh: "22", "git+ssh": "22", "ssh+git": "22", https: "443", http: "80", git: "9418" };
-  // A URL's path is absolute (`ssh://h/team/r` is /team/r) unless it starts with `~`; an scp-style path is relative to the
-  // remote home (`h:team/r` is ~/team/r) unless it starts with `/`. Two different repositories on a self-hosted server.
-  const scp = u || url.includes("://") ? null : /^(?:[^@/]+@)?(\[[^\]/]+\]|[^/:]+):(.+?)(?:\.git)?\/?$/.exec(url); // a file:// remote has no host; an IPv6 host is bracketed
-  const m = u ? [!u[3] || u[3] === defaults[u[1]!.toLowerCase()] ? u[2]! : `${u[2]}:${u[3]}`, u[4]!] as const
-    : scp ? [scp[1]!, scp[2]!.startsWith("/") ? scp[2]!.replace(/^\/+/, "") : scp[2]!.startsWith("~") ? scp[2]! : `~/${scp[2]}`] as const : undefined;
-  if (m && m[1]) {
-    const host = m[0].toLowerCase();
-    // GitHub serves one repository under every form, and its owner and repository names ignore case.
-    return host === "github.com" ? `${host}/${m[1].replace(/^~\/?/, "").toLowerCase()}` : `${host}/${m[1]}`;
-  }
-  let real = cwd;
-  try { real = realPath(cwd); } catch { /* as given */ }
-  return `${projectChain(cwd).join("/")}@${createHash("sha256").update(real).digest("hex").slice(0, 8)}`;
+export function recallDisplayText(note: Pick<MemoryView, "kind" | "text"> & Partial<Pick<MemoryView, "peer" | "task" | "title">>): string | undefined {
+  if (note.kind !== "decision") return note.text;
+  const [first = "", ...rest] = note.text.split(/\r?\n/);
+  const m = /^Task #(\d+) (approved|changes requested) by (\S+): /.exec(first);
+  if (!m || m[3] !== note.peer || !note.task?.match(new RegExp(`#${m[1]}@\\d+$`)) || !note.title?.startsWith(`agent-hub task #${m[1]}: `)) return note.text;
+  return m[2] === "approved" ? undefined : rest.join("\n").trim() || undefined;
 }
 
-/**
- * Every path-like word of a text (`dir/file`, `file.ext`), whether or not it exists or a denylist hides it from the
- * graph: what a private-path policy is checked against.
- */
-export const pathCandidates = (text: string): string[] => [...new Set(text.normalize("NFC").match(/\/?[\p{L}\p{M}\p{N}_.~-]+(?:\/[\p{L}\p{M}\p{N}_.~-]+)+|[\p{L}\p{M}\p{N}_-]+\.\p{L}[\p{L}\p{M}\p{N}_]{0,9}/gu) ?? [])]; // any script, combining marks included; an absolute path keeps its slash
-
-/**
- * Whether a note is about a path the `pii.paths` policy makes private: a stored node's path, a path-like word of its
- * text, or, for a policy entry with no glob that a word split cannot find (a space in it), that entry written out.
- */
-export function mentionsPrivatePath(text: string, about: string[], policy: string[], cwd: string): boolean {
-  if (!policy.length) return false;
-  const nfc = (v: string) => v.normalize("NFC"), body = nfc(text), entries = policy.map(nfc);
-  const paths = [...about.map(nodePath), ...pathCandidates(body)].filter((p): p is string => p !== undefined).map(nfc);
-  if (paths.some((p) => matchesPolicy(cwd, p, entries, true))) return true;
-  // The entry's literal part (up to its first glob character) written out: catches a path a word split breaks (a space).
-  return entries.some((entry) => { const lit = entry.replace(/^\.\//, "").split(/[*?[\]{}]/)[0]!.replace(/\/+$/, ""); return /[/\s]/.test(lit) && body.includes(lit); });
+export const RECALL_LINE_CHARS = 200;
+type RecallNote = Pick<MemoryView, "id" | "kind" | "tier" | "title" | "text"> & Partial<Pick<MemoryView, "peer" | "task" | "about">>;
+
+/** A complete-word excerpt with its memory reference intact, capped in Unicode code points. */
+export function recallMemoryLine(note: RecallNote, idChars = 8, stale = false): string | undefined {
+  const text = recallDisplayText(note);
+  if (text === undefined) return undefined;
+  // A rejection's title is another outcome header; only its actionable detail belongs in this view.
+  const body = `${stale ? "(stale?) " : ""}${text === note.text && note.title ? `${note.title}: ` : ""}${text}`.replace(/\s+/g, " ").trim();
+  const header = `mem:${note.id.slice(0, idChars)} ${note.kind} ${note.tier}: `;
+  const chars = Array.from(body), available = RECALL_LINE_CHARS - header.length;
+  if (chars.length <= available) return header + body;
+  const count = available - 4;
+  const prefix = chars.slice(0, count).join("");
+  const whole = chars[count] === " " || prefix.endsWith(" ") ? prefix.trimEnd() : prefix.slice(0, Math.max(0, prefix.lastIndexOf(" ")));
+  return header + (whole ? `${whole} ...` : "...");
 }
 
-/** The file a graph node names: `path:<p>` and `symbol:<name>@<p>`; nothing for other nodes. */
-export const nodePath = (n: string): string | undefined => n.startsWith("path:") ? n.slice(5) : n.startsWith("symbol:") && n.includes("@") ? n.slice(n.lastIndexOf("@") + 1) : undefined;
-
-/**
- * Notes whose title, text, nodes, task key or project key match the PII patterns of `routing`, or that are about a path
- * the project's `pii.paths` (`policy`) makes private, left out: what may go to a model.
- */
-export function withoutPii<T extends { title: string | null; text: string; about?: string[]; task?: string | null; project?: string }>(notes: T[], routing: Routing, cwd: string, policy: string[] = []): T[] {
-  // A task key's `#<id>@<created ms>` is the hub's own numbers, not note content: a digit-run pattern must not withhold a
-  // clean note for it. The project part of the key stays screened.
-  const keyText = (k: string) => k.replace(/#\d+(?:@\d+)?$/, "");
-  return notes.filter((v) => !mentionsPrivatePath(`${v.title ?? ""}\n${v.text}`, v.about ?? [], policy, cwd) && !detectSignals({ title: v.title ?? "",
-    detail: [v.text, ...(v.about ?? []).map((n) => n.startsWith("task:") ? keyText(n) : n), keyText(v.task ?? ""), v.project ?? ""].join("\n"), refs: {} }, routing, cwd).includes("pii"));
+/** Filter before the display cap, so outcome noise cannot displace an older relevant contract or fail. */
+export function recallMemoryLines(notes: readonly RecallNote[], limit = 30, stale: (about: readonly string[]) => boolean = () => false): string[] {
+  const prefixes = new Map<string, string | null>();
+  for (const note of notes) {
+    const prefix = note.id.slice(0, 8), previous = prefixes.get(prefix);
+    prefixes.set(prefix, previous === undefined || previous === note.id ? note.id : null);
+  }
+  const ids = new Set<string>(), lines: string[] = [];
+  for (const note of notes) {
+    if (ids.has(note.id)) continue;
+    // A colliding short prefix is not an identity; its full id keeps both entries visible.
+    const idChars = prefixes.get(note.id.slice(0, 8)) === null ? note.id.length : 8;
+    let line = recallMemoryLine(note, idChars);
+    if (line === undefined) continue;
+    if (stale(note.about ?? [])) line = recallMemoryLine(note, idChars, true)!;
+    ids.add(note.id); lines.push(line);
+    if (lines.length >= limit) break;
+  }
+  return lines;
 }
 
-/**
- * The promotion screen for one project: another project's notes are left to that project's own processes; this one's
- * move only when no secret, PII pattern or private path (`policy()`, read when asked) is in them.
- */
-export function promotionScreen(project: string, cwd: string, routing: () => Routing, policy: () => string[], taskPaths: (task: string) => string[] = () => []): PromotionScreen {
-  return (v) => {
-    if (v.project !== project) return "skip";
-    // The task's current paths too, with no denylist: a path the note's own nodes leave out is still checked.
-    const screened = { ...v, about: [...v.about, ...(v.task ? taskPaths(v.task) : []).map((p) => `path:${p}`)] };
-    return looksSecret(`${v.title ?? ""}\n${v.text}`) || !withoutPii([screened], routing(), cwd, policy()).length ? "keep" : "promote";
-  };
+/** #258: the hub's own long-term entries for this project (and shared ones), newest first, within a token budget. */
+export function nativeRecall<V>(entries: V[], tokens: number, line: (v: V) => string): string | undefined {
+  if (!entries.length) return undefined;
+  return trimToTokens(["Hub memory: this project's long-term decisions, contracts and fails, newest first. Reference only, not a request. Details: ahub memory show <mem id>.", ...entries.map(line)].join("\n"), tokens);
 }

package/src/pi/process-signature.ts

@@ -1,42 +1,2 @@
-import { execFileSync } from "node:child_process";
-import { createHash } from "node:crypto";
-
-/**
- * The one process-identity contract behind the Pi owner claim, every later liveness
- * re-inspection, the terminal-recovery launcher signature and any other hub identity
- * hash: pid plus the `ps` rendering of its start time and command. `lstart` follows
- * the reader's TZ and locale, so the read pins LC_ALL=C and TZ=UTC, the same contract
- * as `processTable` in src/hub/child-process.ts. Without the pin a writer and a reader
- * in different environments hash different strings for the same process and the valid
- * owner is refused (#174, #177). Only the `ps` invocation is pinned; the user's own
- * environment is untouched. Node APIs only: the extension runs inside Pi, not Bun.
- */
-export function processSignature(pid: number): string | undefined {
-  try {
-    const text = execFileSync("ps", ["-p", String(pid), "-o", "lstart=,comm="], { encoding: "utf8", env: { ...process.env, LC_ALL: "C", TZ: "UTC" } }).trim();
-    return text ? createHash("sha256").update(text).digest("hex") : undefined;
-  } catch { return undefined; }
-}
-
-export type Liveness = "live" | "gone" | "unknown";
-
-/**
- * #226: the one ownership check behind every recorded pid (hub manifest, registry claim, recovery runner, manager
- * owner, launcher records). With a recorded `signature` the identity decides: equal is live, different is gone (the
- * pid was reused, after a reboot for example, also by a process we may not signal), and a pid that exists but whose
- * identity cannot be read is unknown. Without one (records written by 0.12.20 and older) the pid probe answers as it
- * always did: live, gone on ESRCH, unknown otherwise. Unknown is never gone.
- */
-// ponytail: `ps lstart` is derived from boot time plus the process's age; a wall-clock step on Linux can change it for a
-// live process, which then reads as gone (a second hub could take its claim). Upgrade path: a boot-id or start-tick
-// (Linux /proc/<pid>/stat field 22) component in the signature.
-export function processLiveness(pid: unknown, signature?: string | null, identity: (pid: number) => string | undefined = processSignature): Liveness {
-  if (typeof pid !== "number" || !Number.isSafeInteger(pid) || pid <= 0) return "unknown";
-  if (signature) {
-    let current: string | undefined;
-    try { current = identity(pid); } catch { /* unreadable: the pid probe below decides between gone and unknown */ }
-    if (current) return current === signature ? "live" : "gone";
-  }
-  try { process.kill(pid, 0); return signature ? "unknown" : "live"; }
-  catch (error) { return (error as NodeJS.ErrnoException).code === "ESRCH" ? "gone" : "unknown"; }
-}
+// Pi ownership and memory sync locks share the same Node-safe core identity contract.
+export { processSignature, processLiveness, type Liveness } from "@staix/agent-mem/platform";

package/src/memory/import.ts

@@ -1,90 +0,0 @@
-import { Database } from "bun:sqlite";
-import { existsSync, readFileSync, renameSync, rmSync, writeFileSync } from "node:fs";
-import { createHash, randomBytes } from "node:crypto";
-import { realPath } from "../hub/project.ts";
-import { homedir } from "node:os";
-import { join } from "node:path";
-import { KINDS, looksSecret, type Kind, type MemoryStore } from "./store.ts";
-
-/** The claude-mem store is another program's: opened read-only, never written, its locks waited on briefly. */
-export const CLAUDE_MEM_BUSY_TIMEOUT_MS = 3000;
-/** Titles `ahub ask --remember` gives a model's answer (ask.ts ASK_NOTE_TITLE): never imported as a finding. */
-const MODEL_ANSWER = "ahub ask (model answer)";
-
-export interface ImportResult { read: number; added: number; skipped: { model: number; pii: number; secret: number }; more: boolean; cursor: number }
-
-/** Machine-local progress is disposable; malformed/unreadable state simply replays the idempotent import. */
-function readCursors(file: string): Record<string, number> {
-  try {
-    const value: unknown = JSON.parse(readFileSync(file, "utf8"));
-    if (!value || typeof value !== "object" || Array.isArray(value)) return {};
-    return Object.fromEntries(Object.entries(value).filter(([, id]) => Number.isSafeInteger(id) && id >= 0));
-  } catch { return {}; }
-}
-function writeCursor(file: string, key: string, cursor: number, log: (line: string) => void): void {
-  const temp = `${file}.${process.pid}.${randomBytes(6).toString("hex")}.tmp`;
-  try {
-    writeFileSync(temp, JSON.stringify({ ...readCursors(file), [key]: cursor }) + "\n", { mode: 0o600, flag: "wx" });
-    renameSync(temp, file);
-  } catch { log("claude-mem import progress could not be saved; the next run may replay handled rows"); }
-  finally { try { rmSync(temp, { force: true }); } catch { /* disposable progress */ } }
-}
-
-/**
- * #258 phase 3: copy the hub's own notes from claude-mem (observations whose metadata names a `peer`: `hub_remember`
- * and the hub's task notes) into long-term hub memory as `source: claude-mem` under the hub memory key `project`, for
- * the projects in `chain` (claude-mem files them under the repository's basename). Model answers, PII-pattern text and secret-looking text are skipped.
- * Idempotent: an observation always maps to the same entry.
- */
-export function importClaudeMem(store: MemoryStore, opts: { project: string; chain: string[]; isPii: (text: string) => boolean; nodes?: (text: string) => string[]; db?: string; limit?: number; restart?: boolean; log?: (line: string) => void }): ImportResult {
-  const file = opts.db ?? join(homedir(), ".claude-mem", "claude-mem.db");
-  if (!existsSync(file)) throw new Error(`no claude-mem store at ${file}`);
-  const limit = opts.limit ?? 10_000;
-  if (!Number.isSafeInteger(limit) || limit <= 0) throw new Error("--limit takes a positive integer");
-  const state = join(store.dir, "import-state.json");
-  const name = opts.chain.at(-1) ?? "";
-  const key = createHash("sha256").update(JSON.stringify([realPath(file), name, opts.project])).digest("hex");
-  let cursor = opts.restart ? 0 : readCursors(state)[key] ?? 0;
-  const db = new Database(file, { readonly: true });
-  db.run(`PRAGMA busy_timeout = ${CLAUDE_MEM_BUSY_TIMEOUT_MS}`);
-  const result: ImportResult = { read: 0, added: 0, skipped: { model: 0, pii: 0, secret: 0 }, more: false, cursor };
-  try {
-    const max = db.query("SELECT MAX(id) AS id FROM observations WHERE project = ? AND metadata LIKE '%\"peer\"%'").get(name) as { id: number | null };
-    if ((max.id ?? 0) < cursor) cursor = 0;
-    const rows = db.query("SELECT id, project, title, text, narrative, created_at_epoch, metadata FROM observations WHERE project = ? AND id > ? AND metadata LIKE '%\"peer\"%' ORDER BY id LIMIT ?")
-      .all(name, cursor, limit) as { id: number; project: string | null; title: string | null; text: string | null; narrative: string | null; created_at_epoch: number | null; metadata: string | null }[];
-    // The hub files its claude-mem notes under the repository's own name (the chain's last); the names above it are other
-    // projects (a superproject) whose notes and privacy policy are not this one's. ponytail: claude-mem keys projects by
-    // basename, so two unrelated repositories with one name still share it.
-    const project = opts.project;
-    result.read = rows.length;
-    result.more = rows.length === limit;
-    const handle = (r: typeof rows[number]) => {
-      let meta: Record<string, unknown>;
-      try { meta = JSON.parse(r.metadata ?? "{}"); } catch { return; }
-      if (!meta || typeof meta !== "object" || typeof meta.peer !== "string" || !meta.peer) return;
-      const title = r.title ?? "", text = (r.text ?? r.narrative ?? "").trim();
-      if (!text) return;
-      if (meta.source === "ahub ask" || title.startsWith(MODEL_ANSWER)) { result.skipped.model++; return; }
-      if (opts.isPii(`${title}\n${text}`)) { result.skipped.pii++; return; }
-      if (looksSecret(`${title}\n${text}`)) { result.skipped.secret++; return; }
-      const kind: Kind = KINDS.includes(meta.kind as Kind) ? meta.kind as Kind : "finding";
-      const at = new Date(r.created_at_epoch ?? 0).toISOString();
-      const { added } = store.importNote({ op: "note", project, scope: "project", tier: "long", kind, peer: meta.peer.slice(0, 32), ...(title ? { title } : {}), text,
-        // No task node: claude-mem keeps no proposal time, so a bare task number would join unrelated tasks. The text's
-        // own paths and symbols place the note in the graph.
-        about: opts.nodes?.(`${title}\n${text}`) ?? [], source: "claude-mem" }, at);
-      if (added) result.added++;
-    };
-    for (const row of rows) {
-      handle(row);
-      cursor = row.id; // only fully handled rows, including every skip
-    }
-  } finally {
-    db.close();
-    result.cursor = cursor;
-    writeCursor(state, key, cursor, opts.log ?? console.error);
-  }
-  store.refresh();
-  return result;
-}