open-memex 0.7.0-alpha.9 → 0.7.0

package/dist/inventory-html.js

@@ -0,0 +1,150 @@
+/**
+ * HTML renderer for the inventory (D68 follow-up): a single local file
+ * a user opens in any browser to read what the store remembers. It
+ * renders the SAME data layer as the text/JSON formats
+ * (`src/inventory.ts`) — one source, three renderings, no drift.
+ *
+ * Design rules (3-C v2) enforced here:
+ * - Every byte of memory content is HTML-escaped. Memory text can come
+ *   from an imported bundle or a pasted web page; under file:// an
+ *   unescaped <script> would execute in the user's own browser.
+ * - The filter box is plain show/hide over server-rendered entries
+ *   (no innerHTML, no network, no external resources).
+ * - History (superseded versions, retracted, archived) is a folded
+ *   section with supersede-chain pointers — auditable, never mixed
+ *   into "what is remembered now". At scale (>50 current entries) the
+ *   scope sections fold too.
+ * - Read-only: no delete buttons, no server callback. Deletion stays a
+ *   confirmed conversation; the page says so, with the id to quote.
+ */
+import path from "node:path";
+import { PERSONAL_SCOPE } from "./scope.js";
+import { escapeHtml, relativeTime, reviewStateLabel, sourceLabel, } from "./retrieve/display.js";
+const FOLD_THRESHOLD = 50;
+function entryHtml(row, now) {
+    const meta = [escapeHtml(sourceLabel(row.source))];
+    const when = relativeTime(row.created_at, now);
+    if (when)
+        meta.push(escapeHtml(when));
+    if (row.scope_key !== PERSONAL_SCOPE.key) {
+        meta.push(escapeHtml(reviewStateLabel(row.review_state)));
+        if (row.review_state !== "draft") {
+            meta.push(row.file_path.replace(/\\/g, "/").includes("/.ai/open-memex/")
+                ? "file is in the repo"
+                : "file is not in the repo yet");
+        }
+    }
+    if (row.status !== "active")
+        meta.push(escapeHtml(`marked ${row.status}`));
+    return `    <article class="entry">
+      <p class="body">${escapeHtml(row.content.trim())}</p>
+      <p class="meta">${meta.join(" · ")} · <span class="id">id ${escapeHtml(row.id)}</span></p>
+    </article>`;
+}
+function hiddenEntryHtml(row, now) {
+    const when = relativeTime(row.created_at, now);
+    const chain = row.superseded_by
+        ? ` · replaced by <span class="id">${escapeHtml(row.superseded_by)}</span>`
+        : "";
+    return `    <article class="entry hidden-entry">
+      <p class="body">${escapeHtml(row.content.trim())}</p>
+      <p class="meta">${escapeHtml(row.status)}${when ? ` · saved ${escapeHtml(when)}` : ""}${chain} · <span class="id">id ${escapeHtml(row.id)}</span></p>
+    </article>`;
+}
+function sectionHtml(title, blurb, entries, count, fold, open) {
+    if (fold) {
+        return `  <details${open ? " open" : ""}>
+    <summary>${escapeHtml(title)} <span class="count">${count}</span></summary>
+    <p class="blurb">${escapeHtml(blurb)}</p>
+${entries}
+  </details>`;
+    }
+    return `  <section>
+    <h2>${escapeHtml(title)} <span class="count">${count}</span></h2>
+    <p class="blurb">${escapeHtml(blurb)}</p>
+${entries || '    <p class="empty">(nothing here yet)</p>'}
+  </section>`;
+}
+export function renderInventoryHtml(data) {
+    const now = Date.now();
+    const fold = data.total > FOLD_THRESHOLD;
+    const personalCount = data.scopes
+        .filter((s) => s.scopeKey === PERSONAL_SCOPE.key)
+        .reduce((n, s) => n + s.rows.length, 0);
+    const parts = [];
+    data.scopes.forEach((s, i) => {
+        const isPersonal = s.scopeKey === PERSONAL_SCOPE.key;
+        parts.push(sectionHtml(isPersonal ? "About you — personal" : `Project: ${s.projectName}`, isPersonal
+            ? "These describe you, apply in every project, and never leave this machine."
+            : "Project memories. Each entry says whether it is still only on this machine (the outbox) or has reached the repo.", s.rows.map((r) => entryHtml(r, now)).join("\n"), s.rows.length, fold, isPersonal || i === 0));
+    });
+    if (data.outbox.length > 0) {
+        parts.push(sectionHtml("Not in the repo yet — outbox drafts", "These drafts exist only on this machine. They reach the repo through review (submit → promote), never automatically.", data.outbox.map((r) => entryHtml(r, now)).join("\n"), data.outbox.length, fold, false));
+    }
+    if (data.hiddenEntries.length > 0) {
+        const h = data.hiddenEntries.map((r) => hiddenEntryHtml(r, now)).join("\n");
+        parts.push(`  <details>
+    <summary>Replaced &amp; hidden history <span class="count">${data.hiddenEntries.length}</span></summary>
+    <p class="blurb">Older versions and withdrawn memories. Kept so you can audit how a fact changed; none of this is used for recall.</p>
+${h}
+  </details>`);
+    }
+    return `<!doctype html>
+<html lang="en">
+<head>
+<meta charset="utf-8">
+<meta name="viewport" content="width=device-width, initial-scale=1">
+<!-- D70: the page claims it makes no network requests - enforce it. Inline
+     style/script are the only allowances; anything else (a stray <img
+     src>, a remote font) is blocked by the browser, not just by our promise. -->
+<meta http-equiv="Content-Security-Policy" content="default-src 'none'; style-src 'unsafe-inline'; script-src 'unsafe-inline'">
+<title>What OpenMemex remembers</title>
+<style>
+  body { font-family: system-ui, sans-serif; margin: 2rem auto; max-width: 44rem; padding: 0 1rem; color: #1a1a1a; background: #fdfdfb; }
+  h1 { font-size: 1.4rem; margin-bottom: 0.25rem; }
+  h2, summary { font-size: 1.1rem; font-weight: 600; }
+  summary { cursor: pointer; margin: 1.2rem 0 0.4rem; }
+  .sub { color: #666; font-size: 0.9rem; margin-top: 0; }
+  .count { color: #888; font-weight: normal; font-size: 0.85em; }
+  .blurb { color: #555; font-size: 0.9rem; }
+  .entry { border-top: 1px solid #e5e2d9; padding: 0.75rem 0; }
+  .hidden-entry { opacity: 0.75; }
+  .body { white-space: pre-wrap; margin: 0 0 0.35rem; }
+  .meta { color: #666; font-size: 0.82rem; margin: 0; }
+  .id { font-family: ui-monospace, monospace; font-size: 0.78rem; }
+  .empty { color: #888; }
+  .howto { background: #f4f1e8; border-radius: 6px; padding: 0.75rem 1rem; font-size: 0.9rem; }
+  input[type="search"] { width: 100%; padding: 0.5rem; font-size: 1rem; margin: 1rem 0; box-sizing: border-box; }
+  .hidden { display: none; }
+</style>
+</head>
+<body>
+<h1>What OpenMemex remembers about you</h1>
+<p class="sub">Generated ${escapeHtml(data.generatedAt)} · ${data.total} memories (${personalCount} personal, ${data.total - personalCount} project incl. outbox). Read-only report.</p>
+<input type="search" id="filter" placeholder="Filter memories…" aria-label="Filter memories">
+<div class="howto">
+  <strong>Checking my work:</strong> every entry shows where it came from.
+  “I inferred this” means I wrote it from context, not from your words — those are the ones to check.
+  To remove one, tell your agent <em>“forget the memory about …”</em> (quote the id if you like) and it will read the entry back before deleting it — deletion is permanent, there is no undo.
+  A memory that lives in a repo is only truly gone once the deletion is committed.
+</div>
+${parts.join("\n")}
+<script>
+  var input = document.getElementById('filter');
+  input.addEventListener('input', function () {
+    var q = input.value.trim().toLowerCase();
+    var entries = document.querySelectorAll('.entry');
+    for (var i = 0; i < entries.length; i++) {
+      var el = entries[i];
+      el.classList.toggle('hidden', q !== '' && el.textContent.toLowerCase().indexOf(q) === -1);
+    }
+  });
+</script>
+</body>
+</html>
+`;
+}
+/** Default report location: the data dir, never a working tree. */
+export function defaultHtmlOutPath(dataRoot) {
+    return path.join(dataRoot, "inventory.html");
+}

package/dist/inventory.js

@@ -20,29 +20,52 @@ import { formatInventoryLine } from "./retrieve/display.js";
 const BASE_COLS = `id, scope_key, project_name, type, status, review_state,
   source, created_at, updated_at, content, file_path`;
 /**
- * Load the inventory for the given scopes. `projectScopeKey` separates
- * the outbox drafts (they belong to that scope's draft rows).
+ * Load the inventory for the given scopes. `projectScopeKey` separates the
+ * outbox drafts (they belong to that scope's draft rows).
+ *
+ * D70: `hidden: "entries"` fetches the hidden rows themselves (HTML audit
+ * view); the default keeps the cheap COUNT query, because pulling every
+ * superseded body for a text report nobody reads is pure waste.
  */
-export function loadInventory(scopeKeys) {
+export function loadInventory(scopeKeys, opts = {}) {
     const inList = scopeKeys.map(() => "?").join(",");
     const current = db()
         .prepare(`SELECT ${BASE_COLS} FROM memories
        WHERE scope_key IN (${inList}) AND status IN ('active', 'deprecated')
        ORDER BY scope_key, updated_at DESC`)
         .all(...scopeKeys);
-    const hiddenRows = db()
-        .prepare(`SELECT status, COUNT(*) AS n FROM memories
-       WHERE scope_key IN (${inList}) AND status IN ('superseded', 'retracted', 'archived')
-       GROUP BY status`)
-        .all(...scopeKeys);
+    const hiddenEntries = opts.hidden === "entries"
+        ? db()
+            .prepare(`SELECT ${BASE_COLS}, superseded_by FROM memories
+             WHERE scope_key IN (${inList}) AND status IN ('superseded', 'retracted', 'archived')
+             ORDER BY updated_at DESC`)
+            .all(...scopeKeys)
+        : [];
     const hidden = { superseded: 0, retracted: 0, archived: 0 };
-    for (const r of hiddenRows) {
-        if (r.status === "superseded")
-            hidden.superseded = r.n;
-        if (r.status === "retracted")
-            hidden.retracted = r.n;
-        if (r.status === "archived")
-            hidden.archived = r.n;
+    if (hiddenEntries.length > 0) {
+        for (const r of hiddenEntries) {
+            if (r.status === "superseded")
+                hidden.superseded++;
+            if (r.status === "retracted")
+                hidden.retracted++;
+            if (r.status === "archived")
+                hidden.archived++;
+        }
+    }
+    else {
+        const counted = db()
+            .prepare(`SELECT status, COUNT(*) AS n FROM memories
+         WHERE scope_key IN (${inList}) AND status IN ('superseded', 'retracted', 'archived')
+         GROUP BY status`)
+            .all(...scopeKeys);
+        for (const r of counted) {
+            if (r.status === "superseded")
+                hidden.superseded = r.n;
+            if (r.status === "retracted")
+                hidden.retracted = r.n;
+            if (r.status === "archived")
+                hidden.archived = r.n;
+        }
     }
     const outbox = current.filter((r) => r.scope_key !== PERSONAL_SCOPE.key && r.review_state === "draft");
     const outboxIds = new Set(outbox.map((r) => r.id));
@@ -55,14 +78,15 @@ export function loadInventory(scopeKeys) {
         byScope.set(r.scope_key, arr);
     }
     // Personal first, then project scopes by key for a stable order.
+    // D70: every requested scope appears, including one with nothing in it —
+    // "this project has no memories" is part of the answer, and dropping the
+    // section made the report look like the project was never looked at.
     const orderedKeys = [
         ...scopeKeys.filter((k) => k === PERSONAL_SCOPE.key),
-        ...[...byScope.keys()].filter((k) => k !== PERSONAL_SCOPE.key).sort(),
+        ...scopeKeys.filter((k) => k !== PERSONAL_SCOPE.key).sort(),
     ];
-    const scopes = orderedKeys
-        .filter((k) => byScope.has(k))
-        .map((k) => {
-        const rows = byScope.get(k);
+    const scopes = orderedKeys.map((k) => {
+        const rows = byScope.get(k) ?? [];
         return {
             scopeKey: k,
             projectName: rows[0]?.project_name || k,
@@ -74,6 +98,7 @@ export function loadInventory(scopeKeys) {
         scopes,
         outbox,
         hidden,
+        hiddenEntries,
         total: current.length,
     };
 }
@@ -83,9 +108,11 @@ function hiddenLine(data) {
         return "";
     return `Not shown: ${superseded} superseded version(s), ${retracted} retracted, ${archived} archived — inspect with \`open-memex list --include all\`.`;
 }
-function entriesText(rows) {
+function entriesText(rows, startAt = 0) {
+    if (rows.length === 0)
+        return "(nothing remembered in this scope yet)";
     return rows
-        .map((r, i) => formatInventoryLine(i, { ...r, snippet: r.content }, PERSONAL_SCOPE.key))
+        .map((r, i) => formatInventoryLine(startAt + i, { ...r, snippet: r.content }, PERSONAL_SCOPE.key))
         .join("\n");
 }
 /** Plain-text rendering: diffable in any terminal or CI log. */
@@ -93,14 +120,19 @@ export function renderInventoryText(data) {
     const out = [];
     out.push(`What OpenMemex remembers — ${data.generatedAt}`);
     out.push(`${data.total} memories (${data.scopes.reduce((n, s) => n + (s.scopeKey === PERSONAL_SCOPE.key ? s.rows.length : 0), 0)} personal, ${data.outbox.length} in the outbox).`);
+    // D70: one running counter across every section, so a number quoted back
+    // ("delete #3") names exactly one entry in this report.
+    let seq = 0;
     for (const s of data.scopes) {
         const title = s.scopeKey === PERSONAL_SCOPE.key
             ? "About you — personal (never leaves this machine)"
             : `Project: ${s.projectName}`;
-        out.push("", `## ${title} (${s.rows.length})`, entriesText(s.rows));
+        out.push("", `## ${title} (${s.rows.length})`, entriesText(s.rows, seq));
+        seq += s.rows.length;
     }
     if (data.outbox.length > 0) {
-        out.push("", `## Not in the repo yet — outbox drafts (${data.outbox.length})`, "These exist only on this machine. They reach the repo through review (submit → promote), never automatically.", entriesText(data.outbox));
+        out.push("", `## Not in the repo yet — outbox drafts (${data.outbox.length})`, "These exist only on this machine. They reach the repo through review (submit → promote), never automatically.", entriesText(data.outbox, seq));
+        seq += data.outbox.length;
     }
     const hidden = hiddenLine(data);
     if (hidden)
@@ -108,7 +140,14 @@ export function renderInventoryText(data) {
     out.push("", "Read-only report. To remove a memory, tell your agent to forget it — it will read the entry back before deleting (deletion is permanent).");
     return out.join("\n") + "\n";
 }
-/** JSON rendering: same data, for agents. Mirrors the export field names. */
+/**
+ * JSON rendering: same data, for agents. Mirrors the export field names.
+ *
+ * D70: format `/2` drops the absolute `file` path. This artifact is meant
+ * to be handed to an agent — i.e. pasted into a cloud conversation — and it
+ * carried the user's home directory and name with it. The id locates the
+ * file (`open-memex where` prints the data root).
+ */
 export function renderInventoryJson(data) {
     const entry = (r) => ({
         id: r.id,
@@ -121,10 +160,9 @@ export function renderInventoryJson(data) {
         created_at: new Date(r.created_at).toISOString(),
         updated_at: new Date(r.updated_at).toISOString(),
         content: r.content,
-        file: r.file_path,
     });
     return (JSON.stringify({
-        format: "open-memex-inventory/1",
+        format: "open-memex-inventory/2",
         generated_at: data.generatedAt,
         total: data.total,
         scopes: data.scopes.map((s) => ({

package/dist/opencode-v2.js

@@ -1,5 +1,5 @@
 import { z } from "zod";
-import { PLUGIN_ID, bootstrapPlugin, captureFromText, injectOnce, } from "./plugin-core.js";
+import { PLUGIN_ID, bootstrapPlugin, captureFromText, captureHandoff, injectOnce, } from "./plugin-core.js";
 import { makeTools } from "./tools/memory.js";
 /** Register the five memory tools on a v2 host. */
 async function registerTools(ctx, state) {
@@ -28,12 +28,17 @@ export const v2Plugin = {
         const registrations = [];
         await registerTools(ctx, state);
         registrations.push(await ctx.session.hook("prompt", (ev) => {
-            captureFromText(ev.prompt?.text ?? "", state);
+            captureFromText(ev.prompt?.text ?? "", state, ev.sessionID ?? "");
         }));
         registrations.push(await ctx.session.hook("context", (ev) => {
-            injectOnce(ev.sessionID ?? "", state, (block) => {
+            const sessionID = ev.sessionID ?? "";
+            injectOnce(sessionID, state, (block) => {
                 ev.system.push({ type: "text", text: block });
             });
+            // D73: tell the agent what the keyword hook already stored this turn.
+            const handoff = captureHandoff(sessionID, state);
+            if (handoff)
+                ev.system.push({ type: "text", text: handoff });
         }));
         return () => {
             for (const r of registrations)

package/dist/paths.js

@@ -84,6 +84,24 @@ export function inRepoMemoriesDir(root, memoryDir) {
     return dir;
 }
 /** Same as `inRepoMemoriesDir` but never creates the directory. */
+/**
+ * True when a memory file lives inside the user's git working tree (the
+ * in-repo `.ai/open-memex/` copy) rather than in the local data root.
+ *
+ * D70: both destructive/corrective surfaces need this — the hard delete
+ * already said "commit the deletion so the team sees it" (D64), and the
+ * soft hide has to say the same, because a retraction that never gets
+ * committed leaves the memory standing on every teammate's clone.
+ */
+export function isInRepoMemoryFile(filePath) {
+    if (!filePath)
+        return false;
+    const normalized = filePath.replace(/\\/g, "/");
+    return normalized.includes("/.ai/open-memex/") && !normalized.startsWith(root());
+}
+function root() {
+    return paths().root.replace(/\\/g, "/");
+}
 export function inRepoMemoriesDirPath(root, memoryDir) {
     return path.join(root, memoryDir);
 }

package/dist/plugin-core.js

@@ -6,6 +6,7 @@ import { scopeHasFiles } from "./store/migrate.js";
 import { writeMemoryFile, readMemoryFile, ulid, msToRfc3339, } from "./store/markdown.js";
 import { buildContextBlock } from "./retrieve/inject.js";
 import { detectKeywords } from "./capture/keywords.js";
+import { formatHandoffBlock, freshCaptures, } from "./capture/handoff.js";
 import { findDuplicates } from "./store/lifecycle.js";
 import { redact } from "./redact.js";
 /**
@@ -44,14 +45,16 @@ export function bootstrapPlugin(root) {
     catch (err) {
         console.error("[open-memex] init failed:", err);
     }
-    return { cfg, scope, injectedSessions: new Set() };
+    return { cfg, scope, injectedSessions: new Set(), captures: new Map() };
 }
 /**
  * Keyword capture (§ capture): scan one user message for "remember …"
  * triggers and save each hit. Shared by the v1 `chat.message` hook and
- * the v2 session `prompt` hook — both hand us the message text.
+ * the v2 session `prompt` hook — both hand us the message text and the
+ * session id. The session id is what makes the D73 hand-off possible: without
+ * it the agent never learns the sentence is already stored.
  */
-export function captureFromText(text, state) {
+export function captureFromText(text, state, sessionID) {
     const { cfg, scope } = state;
     if (!cfg.keywordCaptureEnabled || !text)
         return;
@@ -106,12 +109,54 @@ export function captureFromText(text, state) {
             // offers no toast channel, so the plugin log is the feedback surface.
             const preview = content.length > 60 ? content.slice(0, 60) + "…" : content;
             console.log(`[open-memex] remembered → ${target.kind} scope: "${preview}"`);
+            // D73 hand-off: the agent gets told about this capture in the turn's
+            // system context, so it does not save the same statement again.
+            recordCapture(state, sessionID, { id: fm.id, scopeKey: target.key, content, at: now });
         }
         catch (err) {
             console.error("[open-memex] keyword capture failed:", err);
         }
     }
 }
+/** Note one hook capture against its session (D73). No-op without a session. */
+function recordCapture(state, sessionID, record) {
+    if (!sessionID)
+        return;
+    const list = state.captures.get(sessionID) ?? [];
+    list.push(record);
+    state.captures.set(sessionID, list);
+}
+/**
+ * D73 hand-off note (a): what the keyword hook already stored for this
+ * session, delivered once per capture into the turn's system context. The
+ * agent cannot avoid re-saving a statement it cannot see is stored, so the
+ * store tells it. Returns "" when there is nothing new to hand off; stale
+ * records are pruned (in-memory only, like `injectedSessions`).
+ *
+ * Both host adapters push this from their system/context hook — the one that
+ * runs before the model request, i.e. after `chat.message` / `prompt`.
+ */
+export function captureHandoff(sessionID, state) {
+    if (!sessionID)
+        return "";
+    const list = state.captures.get(sessionID);
+    if (!list || list.length === 0)
+        return "";
+    const now = Date.now();
+    const fresh = freshCaptures(list, now);
+    if (fresh.length !== list.length) {
+        if (fresh.length === 0)
+            state.captures.delete(sessionID);
+        else
+            state.captures.set(sessionID, fresh);
+    }
+    const pending = fresh.filter((r) => !r.delivered);
+    if (pending.length === 0)
+        return "";
+    for (const r of pending)
+        r.delivered = true;
+    return formatHandoffBlock(pending);
+}
 /**
  * First-turn context injection: exactly once per session. The host adapter
  * supplies `push` (v1: output.system.push; v2: the session context hook's

package/dist/retrieve/display.js

@@ -122,6 +122,10 @@ export function escapeHtml(s) {
  * mouth ("delete #3"), the id is the machine contract. `created=` is
  * when the memory was learned; `updated=` appears only when it moved
  * materially later (supersede/promote touch updated_at).
+ *
+ * D70: `index` must be a running counter across every section of one
+ * listing — a per-section counter produces two "#1"s in a single
+ * `scope: both` output, which makes "delete #3" a guess.
  */
 export function formatInventoryLine(index, hit, personalKey, now = Date.now()) {
     const parts = [
@@ -145,9 +149,13 @@ export function formatInventoryLine(index, hit, personalKey, now = Date.now()) {
     const body = hit.snippet.replace(/\s+/g, " ").trim();
     return `${parts.join(" ")} — ${body}`;
 }
-/** Truncation disclosure (D68): a cut list always says so. */
-export function truncationNote(shown, total) {
+/**
+ * Truncation disclosure (D68): a cut list always says so.
+ * D70: the wording names the surface that can show everything — the CLI —
+ * so a hidden entry is always reachable.
+ */
+export function truncationNote(shown, total, cli = "open-memex") {
     if (total <= shown)
         return null;
-    return `… and ${total - shown} more not shown (raise limit up to 100, or use memory_search to find something specific).`;
+    return `… and ${total - shown} more not shown (raise limit up to 100, run \`${cli} list --limit 100\`, or use memory_search to find something specific).`;
 }

package/dist/retrieve/search.js

@@ -189,9 +189,15 @@ export function list(scopeKey, opts = {}) {
 }
 /**
  * True totals for the inventory's truncation disclosure (D68). Under
- * `active` the visible set is the newest of each chain — which is
- * exactly the rows whose status is active/deprecated, so a plain count
- * matches what resolveVisible would return unbounded.
+ * `active` the visible set is the newest of each chain, which in a
+ * consistent store is exactly the rows whose status is active/deprecated.
+ *
+ * D70: one deliberate exception — a `superseded` row whose chain target is
+ * missing (a dangling pointer, which the read path self-heals with a
+ * warning) is returned as a visible hit by resolveVisible but is not
+ * counted here, so the total can read one low in that state. Not worth
+ * widening the query for a self-healing case; the disclosure stays honest
+ * in every state a user can reach deliberately.
  */
 export function countList(scopeKey, opts = {}) {
     const typeFilter = opts.type ? ` AND type = ?` : "";

package/dist/scope.js

@@ -57,6 +57,23 @@ export function resolveCwdScope(worktree) {
         projectName = "workspace";
     return scopeFromSeed(seed, projectName);
 }
+/** Pick the directory that seeds scope resolution from a host's candidate
+ *  roots. OpenCode v1 hands the plugin both `worktree` (the repo root — but
+ *  the filesystem root, e.g. `C:\` or `/`, when the opened folder is not a
+ *  git repo) and `directory` (the folder actually opened). Seeding on a
+ *  filesystem root collapses every non-git folder on a drive into one shared
+ *  `project__workspace__…` scope (D71), so prefer `worktree` only when it is
+ *  a real directory below the filesystem root. */
+export function pickScopeRoot(worktree, directory) {
+    const isFsRoot = (p) => path.parse(p).root === p;
+    if (worktree && !isFsRoot(worktree))
+        return worktree;
+    if (directory)
+        return directory;
+    if (worktree)
+        return worktree;
+    return process.cwd();
+}
 export function resolveProjectScope(worktree) {
     const target = worktree && worktree.length > 0 ? worktree : ".";
     const remote = tryGitRemote(target);

package/dist/store/lifecycle.js

@@ -5,6 +5,7 @@ import { db } from "./db.js";
 import { paths, projectRoot, inRepoMemoriesDirPath, } from "../paths.js";
 import { loadConfig } from "../config.js";
 import { cjkIndexText } from "../retrieve/cjk.js";
+import { isTurnEcho } from "../capture/handoff.js";
 import { parse, serialize, atomicWriteTextSync, ulid, msToRfc3339, } from "./markdown.js";
 /**
  * Dedup + lifecycle (V2-DESIGN §3.3, §3.4).
@@ -40,6 +41,10 @@ export function similarity(a, b) {
     return union === 0 ? 0 : inter / union;
 }
 export const NEAR_DUP_THRESHOLD = 0.8;
+/** `source` values the keyword hook (or an agent marking a user statement) writes.
+ *  Only these are turn-echo candidates — a `tool` memory is the agent's own
+ *  inference and keeps the 0.8 near-dup notice instead of a refusal. */
+const ECHO_SOURCES = "('keyword','user')";
 /** Find exact + near duplicates of `body` among ACTIVE memories in scope. */
 export function findDuplicates(scopeKey, body, excludeId) {
     const hash = contentHash(body);
@@ -64,6 +69,43 @@ export function findDuplicates(scopeKey, body, excludeId) {
     near.sort((x, y) => y.score - x.score);
     return { exact, near: near.slice(0, 3) };
 }
+/**
+ * D73: memories written from the user's own words moments ago — the keyword
+ * hook's captures, plus agent saves marked `source: user`. `memory_add` uses
+ * this to refuse a re-save of a statement the store already holds verbatim
+ * (see TURN_ECHO_THRESHOLD in src/capture/handoff.ts for why the bar is high).
+ * `created_at` is epoch ms in the index, so the window is a numeric compare.
+ */
+export function findTurnEcho(scopeKey, body, windowMs) {
+    const cutoff = Date.now() - windowMs;
+    let rows;
+    try {
+        rows = db()
+            .prepare(`SELECT id, content, source, created_at FROM memories
+         WHERE scope_key = ? AND status = 'active'
+           AND source IN ${ECHO_SOURCES} AND created_at >= ?`)
+            .all(scopeKey, cutoff);
+    }
+    catch {
+        return [];
+    }
+    const out = [];
+    for (const r of rows) {
+        if (typeof r.created_at !== "number" || r.created_at < cutoff)
+            continue;
+        const score = similarity(body, r.content);
+        if (isTurnEcho(score)) {
+            out.push({
+                id: r.id,
+                score,
+                source: r.source,
+                snippet: r.content.replace(/\s+/g, " ").trim().slice(0, 120),
+            });
+        }
+    }
+    out.sort((x, y) => y.score - x.score);
+    return out.slice(0, 3);
+}
 /** Locate a memory file by id: index file_path first, then dir-scan fallback. */
 export function findMemoryFile(id) {
     const { memories } = paths();