open-memex 0.7.0-alpha.9 → 0.7.0

package/src/inventory.ts

@@ -31,6 +31,7 @@ export interface InventoryRow {
   updated_at: number;
   content: string;
   file_path: string;
+  superseded_by?: string | null;
 }
 
 export interface InventoryData {
@@ -41,6 +42,12 @@ export interface InventoryData {
   outbox: InventoryRow[];
   /** History that exists but is not "remembered": counted, not listed. */
   hidden: { superseded: number; retracted: number; archived: number };
+  /**
+   * The hidden rows themselves — audit surfaces only. D70: loaded when
+   * the caller asks for `hidden: "entries"` (the HTML report); text/json
+   * report the counts and must not pay to load every retired body.
+   */
+  hiddenEntries: InventoryRow[];
   total: number;
 }
 
@@ -48,10 +55,17 @@ 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: string[]): InventoryData {
+export function loadInventory(
+  scopeKeys: string[],
+  opts: { hidden?: "counts" | "entries" } = {},
+): InventoryData {
   const inList = scopeKeys.map(() => "?").join(",");
   const current = db()
     .prepare(
@@ -60,19 +74,36 @@ export function loadInventory(scopeKeys: string[]): InventoryData {
        ORDER BY scope_key, updated_at DESC`,
     )
     .all(...scopeKeys) as unknown as InventoryRow[];
-  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) as unknown as Array<{ status: string; n: number }>;
-
+  const hiddenEntries: InventoryRow[] =
+    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) as unknown as InventoryRow[])
+      : [];
   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) as unknown as Array<{ status: string; n: number }>;
+    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(
@@ -88,26 +119,28 @@ export function loadInventory(scopeKeys: string[]): InventoryData {
     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)!;
-      return {
-        scopeKey: k,
-        projectName: rows[0]?.project_name || k,
-        rows,
-      };
-    });
+  const scopes = orderedKeys.map((k) => {
+    const rows = byScope.get(k) ?? [];
+    return {
+      scopeKey: k,
+      projectName: rows[0]?.project_name || k,
+      rows,
+    };
+  });
 
   return {
     generatedAt: new Date().toISOString(),
     scopes,
     outbox,
     hidden,
+    hiddenEntries,
     total: current.length,
   };
 }
@@ -118,11 +151,12 @@ function hiddenLine(data: InventoryData): string {
   return `Not shown: ${superseded} superseded version(s), ${retracted} retracted, ${archived} archived — inspect with \`open-memex list --include all\`.`;
 }
 
-function entriesText(rows: InventoryRow[]): string {
+function entriesText(rows: InventoryRow[], startAt = 0): string {
+  if (rows.length === 0) return "(nothing remembered in this scope yet)";
   return rows
     .map((r, i) =>
       formatInventoryLine(
-        i,
+        startAt + i,
         { ...r, snippet: r.content },
         PERSONAL_SCOPE.key,
       ),
@@ -137,20 +171,25 @@ export function renderInventoryText(data: InventoryData): string {
   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),
+      entriesText(data.outbox, seq),
     );
+    seq += data.outbox.length;
   }
   const hidden = hiddenLine(data);
   if (hidden) out.push("", hidden);
@@ -161,7 +200,14 @@ export function renderInventoryText(data: InventoryData): string {
   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: InventoryData): string {
   const entry = (r: InventoryRow) => ({
     id: r.id,
@@ -174,12 +220,11 @@ export function renderInventoryJson(data: InventoryData): string {
     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/src/opencode-v2.ts

@@ -3,6 +3,7 @@ import {
   PLUGIN_ID,
   bootstrapPlugin,
   captureFromText,
+  captureHandoff,
   injectOnce,
   type PluginState,
 } from "./plugin-core.ts";
@@ -101,14 +102,18 @@ export const v2Plugin = {
 
     registrations.push(
       await ctx.session.hook("prompt", (ev: V2PromptEvent) => {
-        captureFromText(ev.prompt?.text ?? "", state);
+        captureFromText(ev.prompt?.text ?? "", state, ev.sessionID ?? "");
       }),
     );
     registrations.push(
       await ctx.session.hook("context", (ev: V2ContextEvent) => {
-        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 });
       }),
     );
 

package/src/paths.ts

@@ -96,6 +96,25 @@ export function inRepoMemoriesDir(root: string, memoryDir: string): string {
 }
 
 /** 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: string): boolean {
+  if (!filePath) return false;
+  const normalized = filePath.replace(/\\/g, "/");
+  return normalized.includes("/.ai/open-memex/") && !normalized.startsWith(root());
+}
+
+function root(): string {
+  return paths().root.replace(/\\/g, "/");
+}
+
 export function inRepoMemoriesDirPath(root: string, memoryDir: string): string {
   return path.join(root, memoryDir);
 }

package/src/plugin-core.ts

@@ -12,6 +12,12 @@ import {
 } from "./store/markdown.ts";
 import { buildContextBlock } from "./retrieve/inject.ts";
 import { detectKeywords } from "./capture/keywords.ts";
+import {
+  TURN_ECHO_WINDOW_MS,
+  formatHandoffBlock,
+  freshCaptures,
+  type CaptureRecord,
+} from "./capture/handoff.ts";
 import { findDuplicates } from "./store/lifecycle.ts";
 import { redact } from "./redact.ts";
 
@@ -28,6 +34,12 @@ export interface PluginState {
   scope: Scope;
   /** Sessions that already received the one-time context injection. */
   injectedSessions: Set<string>;
+  /**
+   * D73: what the keyword hook stored this session, so the agent can be told
+   * before it re-saves the same statement. In memory only, like
+   * `injectedSessions` — never persisted, pruned by the turn window.
+   */
+  captures: Map<string, CaptureRecord[]>;
 }
 
 /**
@@ -60,15 +72,21 @@ export function bootstrapPlugin(root: string): PluginState {
   } catch (err) {
     console.error("[open-memex] init failed:", err);
   }
-  return { cfg, scope, injectedSessions: new Set<string>() };
+  return { cfg, scope, injectedSessions: new Set<string>(), 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: string, state: PluginState): void {
+export function captureFromText(
+  text: string,
+  state: PluginState,
+  sessionID?: string,
+): void {
   const { cfg, scope } = state;
   if (!cfg.keywordCaptureEnabled || !text) return;
   const hits = detectKeywords(text, cfg);
@@ -119,12 +137,53 @@ export function captureFromText(text: string, state: PluginState): void {
       // 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: PluginState,
+  sessionID: string | undefined,
+  record: CaptureRecord,
+): void {
+  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: string, state: PluginState): string {
+  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/src/retrieve/display.ts

@@ -132,6 +132,10 @@ export interface InventoryHit {
  * 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: number,
@@ -159,8 +163,12 @@ export function formatInventoryLine(
   return `${parts.join(" ")} — ${body}`;
 }
 
-/** Truncation disclosure (D68): a cut list always says so. */
-export function truncationNote(shown: number, total: number): string | null {
+/**
+ * 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: number, total: number, cli = "open-memex"): string | null {
   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/src/retrieve/search.ts

@@ -266,9 +266,15 @@ export function list(
 
 /**
  * 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: string,

package/src/scope.ts

@@ -68,6 +68,24 @@ export function resolveCwdScope(worktree: string): Scope {
   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?: string | null,
+  directory?: string | null,
+): string {
+  const isFsRoot = (p: string) => 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: string): Scope {
   const target = worktree && worktree.length > 0 ? worktree : ".";
   const remote = tryGitRemote(target);

package/src/store/lifecycle.ts

@@ -9,6 +9,7 @@ import {
 } from "../paths.ts";
 import { loadConfig } from "../config.ts";
 import { cjkIndexText } from "../retrieve/cjk.ts";
+import { isTurnEcho } from "../capture/handoff.ts";
 import {
   parse,
   serialize,
@@ -67,6 +68,11 @@ export interface DupResult {
 
 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')";
+
 interface IndexRow {
   id: string;
   content_hash: string;
@@ -103,6 +109,52 @@ export function findDuplicates(
   return { exact, near: near.slice(0, 3) };
 }
 
+export interface TurnEchoCandidate extends DuplicateCandidate {
+  source: string;
+}
+
+/**
+ * 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: string,
+  body: string,
+  windowMs: number,
+): TurnEchoCandidate[] {
+  const cutoff = Date.now() - windowMs;
+  let rows: Array<{ id: string; content: string; source: string; created_at: number }>;
+  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) as typeof rows;
+  } catch {
+    return [];
+  }
+  const out: TurnEchoCandidate[] = [];
+  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: string): MemoryFile | null {
   const { memories } = paths();

package/src/tools/ops.ts

@@ -7,7 +7,6 @@
  * result; each host adapts that to its own tool-result shape.
  */
 import fs from "node:fs";
-import path from "node:path";
 import { z } from "zod";
 import type { Scope } from "../scope.ts";
 import type { MyOMemoryConfig } from "../config.ts";
@@ -24,12 +23,13 @@ import {
   type Frontmatter,
 } from "../store/markdown.ts";
 import { upsertFromFile, deleteFromIndex } from "../store/sync.ts";
-import { findDuplicates, supersede, setStatus } from "../store/lifecycle.ts";
+import { findDuplicates, findTurnEcho, supersede, setStatus } from "../store/lifecycle.ts";
+import { TURN_ECHO_WINDOW_MS } from "../capture/handoff.ts";
 import { db } from "../store/db.ts";
 import { redact } from "../redact.ts";
 import { getSyncStatus, formatSyncStatus, submitMemories, outboxDraftCount } from "../submit.ts";
 import { getPrStatus, formatPrStatus, applyPrStatus } from "../github.ts";
-import { paths } from "../paths.ts";
+import { isInRepoMemoryFile } from "../paths.ts";
 import {
   proposeMemories,
   promoteMemory,
@@ -66,7 +66,7 @@ export async function withOutboxNote(
 /** LLM-facing tool descriptions, shared by the opencode plugin and the MCP server. */
 export const TOOL_DESCRIPTIONS = {
   memory_add:
-    "Save a fact, preference, decision, or note to persistent local memory. Call this PROACTIVELY whenever the user shares something worth remembering across sessions — project conventions, tool choices, personal preferences, decisions made, error fixes and their causes. Worth saving: decisions and their reasons, preferences, conventions, gotchas, approaches tried and abandoned. Not worth saving: one-off task details or anything re-derivable from the code. Do not wait to be asked. For facts you infer yourself rather than the user stating, propose them first and save only on approval. Keep each memory to one self-contained statement; attach aliases when the parameter is available. Default scope is the current project; use the personal scope for facts about the user that apply across all projects.",
+    "Save a fact, preference, decision, or note to persistent local memory. Call this PROACTIVELY whenever the user shares something worth remembering across sessions — project conventions, tool choices, personal preferences, decisions made, error fixes and their causes. Worth saving: decisions and their reasons, preferences, conventions, gotchas, approaches tried and abandoned. Not worth saving: one-off task details or anything re-derivable from the code. Do not wait to be asked. For facts you infer yourself rather than the user stating, propose them first and save only on approval. Keep each memory to one self-contained statement; attach aliases when the parameter is available. If a note tells you the user's own wording was already stored verbatim this turn, that statement is already saved: do not retry it in a rewording — save only what that text does not contain, or use memory_supersede on the given id. Default scope is the current project; use the personal scope for facts about the user that apply across all projects.",
   memory_search:
     "Search persistent memory by keyword (BM25 full-text). Returns matching memories from the current project and/or personal scope. Call before asking the user about past decisions, conventions, or preferences they may have told you before. Search well: break the question into its concepts and try 2–3 phrasings per concept — synonyms, the user's other language, shorter keyword forms — and check the other scope too, before concluding nothing is stored.",
   memory_list:
@@ -295,6 +295,27 @@ export async function addMemory(
       output: `Identical memory already exists: id=${dups.exact.id}. Not duplicated.`,
     };
   }
+  // D73: one user statement, one memory. The keyword hook stores the user's
+  // sentence verbatim with no agent in the loop; a paraphrase of that same
+  // sentence is refused instead of written beside it. The stored id comes back
+  // so the caller can supersede it or save only the genuinely new part.
+  const echo = findTurnEcho(s.key, redacted, TURN_ECHO_WINDOW_MS);
+  if (echo.length > 0) {
+    const top = echo[0];
+    const others = echo
+      .slice(1)
+      .map((e) => `id=${e.id} (${e.source}, overlap ${e.score.toFixed(2)})`)
+      .join(", ");
+    return {
+      title: "memory: already captured verbatim",
+      output:
+        `Not saved — the user's own words were already stored moments ago (source: ${top.source}, overlap ${top.score.toFixed(2)}): ` +
+        `id=${top.id} — ${top.snippet}` +
+        (others ? `\nAlso matching: ${others}` : "") +
+        `\nDo not retry with a rewording: that only adds a second copy of one statement. ` +
+        `Save a separate memory only for information that stored text does not contain, or call memory_supersede on that id if this replaces it.`,
+    };
+  }
   const fm = buildFrontmatter(s, {
     type: args.type ?? "fact",
     tags: args.tags ?? [],
@@ -357,10 +378,13 @@ export async function listMemories(
   // every section reports its true total — a truncated list says so
   // instead of quietly looking complete (the D66 sync-status lesson).
   const include = args.include ?? "active";
+  // D70: numbering runs across every section of THIS listing, so "delete
+  // #3" names exactly one memory. A per-section counter emitted two "#1"s.
+  let seq = 0;
   const render = (scopeKey: string) => {
     const hits = list(scopeKey, { type: args.type, limit: args.limit, include });
     const total = countList(scopeKey, { type: args.type, include });
-    const lines = hits.map((h, i) => formatInventoryLine(i, h, PERSONAL_SCOPE.key));
+    const lines = hits.map((h) => formatInventoryLine(seq++, h, PERSONAL_SCOPE.key));
     const note = truncationNote(hits.length, total);
     if (note) lines.push(note);
     return lines;
@@ -455,7 +479,14 @@ export async function forgetMemory(args: MemoryForgetArgs): Promise<ToolResult>
       upsertFromFile(mf);
       return {
         title: "memory: hidden",
-        output: `Hidden ${args.id} (retracted). It no longer appears in lists or search, but the file is kept. This is one-way — to bring the fact back, save it again as a new memory.`,
+        output:
+          `Hidden ${args.id} (retracted). It no longer appears in lists or search, but the file is kept. This is one-way — to bring the fact back, save it again as a new memory.` +
+          // D70: a retraction of an in-repo memory is a local working-tree
+          // edit like the delete — without a commit (and a push) the memory
+          // stands on every teammate's clone, so "hidden" would be a lie.
+          (isInRepoMemoryFile(row.file_path)
+            ? ` Note: this memory lives in the repo (.ai/open-memex/), so the retraction is only local until you commit and push it — until then the team still sees it.`
+            : ""),
       };
     } catch (e) {
       return { title: "memory: hide failed", output: (e as Error).message };
@@ -482,9 +513,7 @@ export async function forgetMemory(args: MemoryForgetArgs): Promise<ToolResult>
   // D64: forgetting an in-repo memory deletes a file inside the user's
   // git working tree. Say so — the deletion should ride a commit, or the
   // file silently diverges from what teammates have.
-  const inRepo =
-    row.file_path.includes(`${path.sep}.ai${path.sep}`) &&
-    !row.file_path.startsWith(paths().root);
+  const inRepo = isInRepoMemoryFile(row.file_path);
   return {
     title: "memory: forgotten",
     output: inRepo