@arkimedehq/openclaw-recordare 0.2.0 → 0.4.0

package/README.md

@@ -24,7 +24,9 @@ own [Recordare](../../README.md) service — the **full** client level:
 It does not take OpenClaw's memory slot: `memory-core` (`MEMORY.md`, `memory_search`) keeps working beside it. Recordare
 stores every turn the plugin sends (it has no consent flag, D50). The plugin never blocks or breaks a turn: every call
 is time-boxed (3 s before the turn), failures are logged without content, captured messages that could not be sent are
-retried in the background for about ten minutes (in memory: a Gateway restart drops them).
+retried in the background for a few hours, from a queue on disk that survives a Gateway restart
+(`<OpenClaw state dir>/recordare/outbox`, normally `~/.openclaw/recordare/outbox`, owner-only files; only unsent
+messages are written there, and each file is deleted once Recordare has it).
 
 Requires OpenClaw ≥ 2026.9.9 (Node ≥ 24, as OpenClaw itself).
 
@@ -45,7 +47,7 @@ Requires OpenClaw ≥ 2026.9.9 (Node ≥ 24, as OpenClaw itself).
      Recordare or auto-provisioned if the client allows it); a client key is also what one memory per person needs.
 
    The memory's **mode** and **gender** are set by the admin (`PATCH api/v1/admin/memories/{id}` `{mode, gender}`), or
-   with a client key by `PATCH api/v1/me`: `personal` (your own assistant: you are "I", what arrives undeclared is
+   with a client key or the personal token by `PATCH api/v1/me`: `personal` (your own assistant: you are "I", what arrives undeclared is
    yours) or `entity` (an agent shared by a family, a team, a place: what arrives undeclared is "someone"'s); `gender`
    `masculine` (default) | `feminine` | `neutral` for the first person in gendered languages. The plugin has no setting
    for them.
@@ -93,6 +95,15 @@ list your ids there (or have the admin bind them to the memory's self, `POST api
 people's words are kept as theirs (role `other`, attributed to their contact), so what they say about themselves never
 becomes a fact about you.
 
+**Or link your sender id with a code** (D51, personal memories). Make a one-time code — the admin console's "Link code"
+on the memory, or `POST api/v1/me/link-codes` with the memory's personal token (`→ {"code": "RCD-…", "expiresAt": …}`,
+ten minutes) — and send it alone to the agent in a **direct chat** from your channel account. The plugin sends it to
+Recordare at once (never stored as a message) and tells the model only to say that the code was received; then confirm
+the claim in the console ("To confirm" → "It is the holder") or with `GET api/v1/me/identities` and `POST
+api/v1/me/identities/pending/{id}/confirm`, within seven days. From then on that sender is you; earlier messages keep
+their attribution. The plugin marks group, channel and room sessions (by their session key) as groups, where a code
+claims nothing.
+
 **Upgrading from a `users` map.** The earlier behaviour (each mapped sender a separate Recordare user, unmapped senders
 not remembered) is `memoryPer: "user"`: add it to keep your memories split per person.
 

package/README_it.md

@@ -26,8 +26,10 @@ tenuta dal tuo servizio [Recordare](../../README_it.md) — il livello client **
 Non occupa lo slot memoria di OpenClaw: `memory-core` (`MEMORY.md`, `memory_search`) continua a funzionare accanto.
 Recordare conserva ogni turno che il plugin invia (non ha un flag di consenso, D50). Il plugin non blocca né rompe mai
 un turno: ogni chiamata ha un limite di tempo (3 s prima del turno), gli errori finiscono nel log senza contenuti, i
-messaggi catturati non inviati vengono ritentati in background per una decina di minuti (in memoria: un riavvio del
-Gateway li perde).
+messaggi catturati non inviati vengono ritentati in background per qualche ora, da una coda su disco che sopravvive a un
+riavvio del Gateway (`<cartella di stato di OpenClaw>/recordare/outbox`, di solito `~/.openclaw/recordare/outbox`, file
+leggibili solo dal proprietario; ci finiscono solo i messaggi non inviati, e ogni file viene cancellato appena Recordare
+lo ha ricevuto).
 
 Richiede OpenClaw ≥ 2026.9.9 (Node ≥ 24, come OpenClaw stesso).
 
@@ -49,7 +51,7 @@ Richiede OpenClaw ≥ 2026.9.9 (Node ≥ 24, come OpenClaw stesso).
      per persona.
 
    **Modalità** e **genere** della memoria li imposta l'amministratore (`PATCH api/v1/admin/memories/{id}`
-   `{mode, gender}`), oppure, con una chiave client, `PATCH api/v1/me`: `personal` (il tuo assistente: tu sei l'"io",
+   `{mode, gender}`), oppure, con una chiave client o il token personale, `PATCH api/v1/me`: `personal` (il tuo assistente: tu sei l'"io",
    ciò che arriva senza identità dichiarata è tuo) o `entity` (un agente condiviso da una famiglia, un team, un luogo:
    ciò che arriva senza identità è di "qualcuno"); `gender` `masculine` (default) | `feminine` | `neutral` per la prima
    persona nelle lingue con il genere. Il plugin non ha impostazioni per questi valori.
@@ -97,6 +99,15 @@ non tu: elenca lì i tuoi id (oppure chiedi all'amministratore di legarli al sé
 di scrivere la prima volta). Le parole degli altri restano loro (ruolo `other`, attribuite al loro contatto), così ciò
 che dicono di sé non diventa mai un fatto su di te.
 
+**Oppure collega il tuo sender id con un codice** (D51, memorie personali). Crea un codice monouso — "Codice di collegamento" sulla
+memoria nella console di amministrazione, oppure `POST api/v1/me/link-codes` con il token personale della memoria
+(`→ {"code": "RCD-…", "expiresAt": …}`, dieci minuti) — e invialo da solo all'agente in una **chat diretta** dal tuo
+account del canale. Il plugin lo invia subito a Recordare (non viene mai salvato come messaggio) e dice al modello solo di
+rispondere che il codice è arrivato; poi conferma la richiesta nella console ("Da confermare" → "È il titolare") oppure
+con `GET api/v1/me/identities` e `POST api/v1/me/identities/pending/{id}/confirm`, entro sette giorni. Da allora quel
+mittente sei tu; i messaggi precedenti mantengono la loro attribuzione. Il plugin considera gruppi le sessioni di gruppo,
+canale e stanza (dalla chiave di sessione), dove un codice non chiede nulla.
+
 **Aggiornare da una mappa `users`.** Il comportamento precedente (ogni mittente mappato un utente Recordare separato, i
 non mappati non ricordati) è `memoryPer: "user"`: aggiungilo per tenere le memorie divise per persona.
 

package/dist/index.js

@@ -7300,6 +7300,8 @@ var require_content_type = __commonJS({
 });
 
 // src/index.ts
+import { homedir } from "node:os";
+import { join as join2 } from "node:path";
 import { definePluginEntry } from "openclaw/plugin-sdk/plugin-entry";
 import { isCronSessionKey, isIncognitoSessionKey, isSubagentSessionKey } from "openclaw/plugin-sdk/routing";
 
@@ -17504,8 +17506,8 @@ async function random(size) {
   const evenDistCutoff = Math.pow(2, 8) - Math.pow(2, 8) % mask.length;
   let result = "";
   while (result.length < size) {
-    const randomBytes = await getRandomValues(size - result.length);
-    for (const randomByte of randomBytes) {
+    const randomBytes2 = await getRandomValues(size - result.length);
+    for (const randomByte of randomBytes2) {
       if (randomByte < evenDistCutoff) {
         result += mask[randomByte % mask.length];
       }
@@ -19070,7 +19072,7 @@ var RecordareMcp = class {
       },
       requestInit: { headers: { ...this.http.headers(user), [CONVERSATION_HEADER]: conversation } }
     });
-    const client = new Client(this.options.clientInfo ?? { name: "recordare-client", version: "0.2.0" });
+    const client = new Client(this.options.clientInfo ?? { name: "recordare-client", version: "0.4.0" });
     await client.connect(transport);
     return client;
   }
@@ -19109,6 +19111,33 @@ var RecordareClient = class {
       throw err;
     }
   }
+  /**
+   * Erases the whole memory behind `user`, at once and for good (needs the `erase` scope): everything it holds goes.
+   * `memoryId` (from `me`) confirms which memory; a user without a memory answers 404, none is created.
+   */
+  eraseMemory(user, memoryId) {
+    return this.http.request("DELETE", `api/v1/me${qs({ confirm: memoryId })}`, { user });
+  }
+  /** A one-time code for the holder to send from a channel (D51; personal memories only, else 409). */
+  linkCode(user) {
+    return this.http.request("POST", "api/v1/me/link-codes", { user });
+  }
+  /** The identities that speak as the memory's "I" and the claims waiting for confirmation (D51). */
+  holderIdentities(user) {
+    return this.http.request("GET", "api/v1/me/identities", { user });
+  }
+  /** Confirms a claim: that channel identity is the holder from now on. */
+  async confirmHolderClaim(user, id) {
+    await this.http.request("POST", `api/v1/me/identities/pending/${encodeURIComponent(id)}/confirm`, { user });
+  }
+  /** Rejects a claim (not the holder). */
+  async rejectHolderClaim(user, id) {
+    await this.http.request("DELETE", `api/v1/me/identities/pending/${encodeURIComponent(id)}`, { user });
+  }
+  /** Unlinks one of the holder's identities. */
+  async unlinkHolderIdentity(user, id) {
+    await this.http.request("DELETE", `api/v1/me/identities/${encodeURIComponent(id)}`, { user });
+  }
   /**
    * Sends messages of one conversation, split into requests of at most MAX_MESSAGES_PER_REQUEST. Idempotent: Recordare
    * deduplicates on each message's externalId. Recordare always stores (D50): the on/off switch is the platform's.
@@ -19133,20 +19162,44 @@ var RecordareClient = class {
     }
     return total;
   }
+  /**
+   * Sends a room transcript to the memories of the people present (continuous listening), split into requests of at
+   * most MAX_MESSAGES_PER_REQUEST; needs a client key (not a personal token). Idempotent like `ingest`.
+   */
+  async ingestRoom(req) {
+    const total = /* @__PURE__ */ new Map();
+    for (let i = 0; i < req.messages.length; i += MAX_MESSAGES_PER_REQUEST) {
+      const last = i + MAX_MESSAGES_PER_REQUEST >= req.messages.length;
+      const part = await this.http.request("POST", "api/v1/ingest/room", {
+        body: { ...req, messages: req.messages.slice(i, i + MAX_MESSAGES_PER_REQUEST), hints: req.hints && last ? req.hints : void 0 }
+      });
+      for (const r of part.recipients) {
+        const t = total.get(r.user);
+        if (!t) total.set(r.user, { ...r, conflicts: [...r.conflicts] });
+        else {
+          t.conversationId = r.conversationId ?? t.conversationId;
+          t.accepted += r.accepted;
+          t.duplicates += r.duplicates;
+          t.conflicts.push(...r.conflicts);
+        }
+      }
+    }
+    return { recipients: [...total.values()] };
+  }
   /**
    * The memories relevant to `query` (the message about to be answered) as a fenced block to append to the prompt — or
    * null. Append it at the end of the system prompt (it changes every turn: keep the stable part first for prompt
-   * caching); never store it as a chat message.
+   * caching); never store it as a chat message. `card`: open it with the self card (who I am), off by default.
    */
-  context(user, conversation, query) {
-    return this.http.request("POST", "api/v1/context", { user, body: { query }, headers: { [CONVERSATION_HEADER]: conversation } });
+  context(user, conversation, query, opts = {}) {
+    return this.http.request("POST", "api/v1/context", { user, body: { query, ...opts }, headers: { [CONVERSATION_HEADER]: conversation } });
   }
   /**
    * Stores the turn and returns the memory context for it in one round trip (needs the `ingest` and `read` scopes):
    * the context is computed for the ingested conversation, from `query` or else the turn's last user message.
    */
-  contextWithTurn(user, turn, query) {
-    return this.http.request("POST", "api/v1/context", { user, body: { ingest: turn, ...query ? { query } : {} } });
+  contextWithTurn(user, turn, query, opts = {}) {
+    return this.http.request("POST", "api/v1/context", { user, body: { ingest: turn, ...query ? { query } : {}, ...opts } });
   }
   /** The conversation ended (session closed, /new): extraction runs now. A conversation Recordare never had is done. */
   async endConversation(user, conversation) {
@@ -19206,12 +19259,23 @@ var RecordareClient = class {
   async forgetEpisode(user, id) {
     await this.http.request("DELETE", `api/v1/episodes/${enc(id)}`, { user });
   }
+  /**
+   * The person forgets a period (days or months, inclusive): its episodes and raw messages (`keepRaw`: kept but hidden
+   * and never extracted again), with what only they supported. Returns how much went.
+   */
+  forgetPeriod(user, period) {
+    return this.http.request("POST", "api/v1/forget", { user, body: period });
+  }
   digests(user, query = {}) {
     return this.http.request("GET", `api/v1/digests${qs(query)}`, { user });
   }
   facts(user, query = {}) {
     return this.http.request("GET", `api/v1/facts${qs(query)}`, { user });
   }
+  /** Who I am and who my contacts are: current facts and notes of the self and of each contact (no LLM). */
+  cards(user) {
+    return this.http.request("GET", "api/v1/cards", { user });
+  }
   notes(user, query = {}) {
     return this.http.request("GET", `api/v1/notes${qs(query)}`, { user });
   }
@@ -19230,6 +19294,54 @@ var RecordareClient = class {
   async decide(user, what, id, decision) {
     await this.http.request("POST", `api/v1/${what}/${enc(id)}/${decision}`, { user });
   }
+  /** The person writes an episode in the platform's UI (stated, theirs). Returns its id. */
+  async addEpisode(user, episode) {
+    return (await this.http.request("POST", "api/v1/episodes", { user, body: episode })).id;
+  }
+  /** The person writes a note in the platform's UI (stated, theirs). Returns its id. */
+  async addNote(user, note) {
+    return (await this.http.request("POST", "api/v1/notes", { user, body: note })).id;
+  }
+  fact(user, id) {
+    return this.http.request("GET", `api/v1/facts/${enc(id)}`, { user });
+  }
+  note(user, id) {
+    return this.http.request("GET", `api/v1/notes/${enc(id)}`, { user });
+  }
+  /** The person corrects a current fact (`value` null: not known any more); the wrong one stays in its history. */
+  async correctFact(user, id, fix) {
+    return (await this.http.request("POST", `api/v1/facts/${enc(id)}/corrections`, { user, body: fix })).id;
+  }
+  /** The person corrects a current note; the wrong one stays as `corrected`. */
+  async correctNote(user, id, fix) {
+    return (await this.http.request("POST", `api/v1/notes/${enc(id)}/corrections`, { user, body: fix })).id;
+  }
+  /** The notes change feed, for a platform keeping a copy: pass `next` back as `since`; `more` when the page was full. */
+  noteChanges(user, query = {}) {
+    return this.http.request("GET", `api/v1/notes/changes${qs(query)}`, { user });
+  }
+  settings(user) {
+    return this.http.request("GET", "api/v1/settings", { user });
+  }
+  /** Needs `memory_settings`: the memory's personal token (never a client key); pass `user` empty with it. */
+  updateSettings(user, patch) {
+    return this.http.request("PATCH", "api/v1/settings", { user, body: patch });
+  }
+  /** LLM calls and tokens spent on the memory between two local days (default: the last 30). */
+  usage(user, query = {}) {
+    return this.http.request("GET", `api/v1/usage${qs(query)}`, { user });
+  }
+  /** Starts a full export (needs `export`: the memory's personal token); poll `exportJob`, then `exportArchive`. */
+  startExport(user) {
+    return this.http.request("POST", "api/v1/exports", { user });
+  }
+  exportJob(user, id) {
+    return this.http.request("GET", `api/v1/exports/${enc(id)}`, { user });
+  }
+  /** The finished export: one JSON archive (`format: "recordare-export/1"`). */
+  exportArchive(user, id) {
+    return this.http.request("GET", `api/v1/exports/${enc(id)}/archive`, { user });
+  }
   /** Closes the MCP sessions (on shutdown). */
   close() {
     return this.mcp.close();
@@ -19371,7 +19483,7 @@ var TOOLS = [
   {
     "name": "log_episode",
     "title": "Note something that happened or is planned",
-    "description": 'Explicit capture ("note that today I serviced the car"). Resolve the date yourself (ISO).',
+    "description": 'Explicit capture ("note that today I serviced the car"). Resolve the date yourself (ISO). Conversations are remembered automatically: use it only when explicitly asked, and never ask whether to remember or save something.',
     "inputSchema": {
       "type": "object",
       "properties": {
@@ -19421,7 +19533,7 @@ var TOOLS = [
   {
     "name": "remember",
     "title": "Remember something",
-    "description": 'Explicit "remember that\u2026" about preferences, habits, values, knowledge.',
+    "description": 'Explicit "remember that\u2026" about preferences, habits, values, knowledge. Conversations are remembered automatically: use it only when explicitly asked, and never ask whether to remember or save something.',
     "inputSchema": {
       "type": "object",
       "properties": {
@@ -19467,7 +19579,7 @@ var TOOLS = [
   {
     "name": "search_episodes",
     "title": "Search what happened",
-    "description": 'Search your memory of what happened: what you lived, did, planned or learned, and what happened to the people you know (events, plans, changes), with dates and status. Each item has a subject: you (written in the first person), a person by name, someone, or undecided. Use `from`/`to` (ISO dates, inclusive; see resolve_period) for questions about a period. mode: "search" = most relevant, "list" = chronological in the period (overviews, counting), "latest" = most recent first ("when did I last\u2026").',
+    "description": 'Search your memory of what happened: what you lived, did, planned or learned, and what happened to the people you know (events, plans, changes), with dates and status. Each item has a subject: you (written in the first person), a person by name, someone, or undecided. Use `from`/`to` (ISO dates, inclusive; see resolve_period) for questions about a period; a vague span ("lately", "these weeks") is not a period: leave them out. mode: "search" = most relevant, "list" = chronological in the period (overviews, counting), "latest" = most recent first ("when did I last\u2026"). An item or chat excerpt marked `heard` was overheard in the room by a listening device, not said to you: tell it as heard at home, and its speaker may have been misrecognised \u2014 what it says of you may be someone else\'s. A chat excerpt by `assistant` is your own earlier reply: what you told them then (advice, a recipe, a name), not something they lived.',
     "inputSchema": {
       "type": "object",
       "properties": {
@@ -19531,7 +19643,7 @@ var TOOLS = [
   {
     "name": "search_memory",
     "title": "Search what you know about yourself and others",
-    "description": 'Search your memory of preferences, habits, values, relationships, knowledge and current state (car, home, job\u2026) \u2014 yours and of the people you know; each item has its subject. Use `as_of` (ISO date) for "what was it on that date" questions; each fact comes with its history.',
+    "description": 'Search your memory of preferences, habits, values, relationships, knowledge and current state (car, home, job\u2026) \u2014 yours and of the people you know; each item has its subject. Use `as_of` (ISO date) for "what was it on that date" questions; each fact comes with its history. A note with `pattern` is a habit you noticed yourself in repeated episodes, not something said: tell it as such.',
     "inputSchema": {
       "type": "object",
       "properties": {
@@ -19556,6 +19668,13 @@ var TOOLS = [
   }
 ];
 
+// ../../packages/client/src/links.ts
+var LINK_CODE = /^\s*RCD-?[0-9A-Z]{4}-?[0-9A-Z]{4}\.?\s*$/i;
+function isLinkCode(text) {
+  return LINK_CODE.test(text);
+}
+var LINK_CODE_INSTRUCTION = "The user's last message is a one-time code that links their account on this channel to their memory (Recordare); it is handled automatically. Reply only, briefly and in the user's language, that the code was received and that they now confirm the link where they created the code. Do not repeat the code.";
+
 // ../../packages/client/src/delivery.ts
 var DEFAULT_DELIVERY = { maxAttempts: 12, baseDelayMs: 5e3, maxDelayMs: 60 * 60 * 1e3 };
 function backoffMs(attempts, policy = DEFAULT_DELIVERY) {
@@ -19606,6 +19725,80 @@ function isSystemRun(ctx) {
   return ctx.trigger === "cron" || ctx.trigger === "heartbeat" || ctx.inputProvenance?.kind === "internal_system" || ctx.inputProvenance?.kind === "inter_session";
 }
 
+// src/outbox.ts
+import { randomBytes } from "node:crypto";
+import { mkdirSync, readdirSync, readFileSync, renameSync, unlinkSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+var FILE = /^\d{15}-[0-9a-f]{12}\.json$/;
+function pendingId(now = Date.now()) {
+  return `${String(now).padStart(15, "0")}-${randomBytes(6).toString("hex")}`;
+}
+var Outbox = class {
+  constructor(dir, warn) {
+    this.warn = warn;
+    this.dir = dir;
+    if (!dir) return;
+    try {
+      mkdirSync(dir, { recursive: true, mode: 448 });
+    } catch (err) {
+      this.disable(err);
+    }
+  }
+  dir;
+  get durable() {
+    return this.dir !== null;
+  }
+  /** The batches left by a previous run, oldest first; unreadable files are dropped (logged). */
+  load() {
+    if (!this.dir) return [];
+    let names;
+    try {
+      names = readdirSync(this.dir).filter((n) => FILE.test(n)).sort();
+    } catch (err) {
+      this.disable(err);
+      return [];
+    }
+    const out = [];
+    for (const name of names) {
+      const path = join(this.dir, name);
+      try {
+        const p = JSON.parse(readFileSync(path, "utf8"));
+        if (typeof p.user !== "string" || !Array.isArray(p.req?.messages)) throw new Error("not a batch");
+        out.push({ ...p, id: name.slice(0, -".json".length) });
+      } catch {
+        this.warn(`recordare: dropped an unreadable queued batch (${name})`);
+        try {
+          unlinkSync(path);
+        } catch {
+        }
+      }
+    }
+    return out;
+  }
+  /** Writes (or rewrites) a batch atomically: a temporary file renamed over the old one. */
+  save(p) {
+    if (!this.dir) return;
+    const path = join(this.dir, `${p.id}.json`);
+    try {
+      writeFileSync(`${path}.tmp`, JSON.stringify(p), { mode: 384 });
+      renameSync(`${path}.tmp`, path);
+    } catch (err) {
+      this.disable(err);
+    }
+  }
+  remove(p) {
+    if (!this.dir) return;
+    try {
+      unlinkSync(join(this.dir, `${p.id}.json`));
+    } catch {
+    }
+  }
+  disable(err) {
+    this.warn(`recordare: retry queue kept in memory only, its folder is not usable (${err instanceof Error ? err.message : "error"})`);
+    this.dir = null;
+  }
+};
+
 // src/tools.ts
 var OFFERED = TOOLS.filter((t) => t.name !== "log_episode");
 var NAMES = new RegExp(`\\b(${OFFERED.map((t) => t.name).join("|")})\\b`, "g");
@@ -19660,9 +19853,10 @@ function lastTurn(messages) {
 }
 
 // src/plugin.ts
-var VERSION = "0.2.0";
+var VERSION = "0.4.0";
 var TOOL_TIMEOUT_MS = 2e4;
-var RETRY = { maxAttempts: 8, baseDelayMs: 2e3, maxDelayMs: 5 * 6e4 };
+var RETRY = { maxAttempts: 16, baseDelayMs: 2e3, maxDelayMs: 60 * 6e4 };
+var RESUME_MS = 5e3;
 var MAX_QUEUE = 500;
 var MAX_TRACKED = 500;
 var MAX_GROUP_BUFFER = 50;
@@ -19684,7 +19878,7 @@ function withTimeout(p, ms) {
     })
   ]).finally(() => clearTimeout(timer));
 }
-function registerRecordare(api, cfg, kinds) {
+function registerRecordare(api, cfg, kinds, outboxDir = null) {
   const log = api.logger;
   const clientInfo = { name: "openclaw-recordare", version: VERSION };
   const fast = new RecordareClient({ baseUrl: cfg.url, apiKey: cfg.apiKey, timeoutMs: cfg.timeoutMs, mcp: { clientInfo } });
@@ -19695,7 +19889,8 @@ function registerRecordare(api, cfg, kinds) {
   const groupBuffer = /* @__PURE__ */ new Map();
   const groupParticipants = /* @__PURE__ */ new Map();
   const names = /* @__PURE__ */ new Map();
-  const queue = [];
+  const outbox = new Outbox(outboxDir, (m) => log.warn(m));
+  const queue = outbox.load();
   let timer;
   let stopped = false;
   if (cfg.memoryPer === "agent" && !cfg.defaultUser) {
@@ -19708,18 +19903,21 @@ function registerRecordare(api, cfg, kinds) {
     try {
       const res = await slow.ingest(headerUser(p.user), p.req);
       if (res.conflicts.length) log.warn(`recordare: ${res.conflicts.length} message id(s) conflicted (kept the stored version)`);
+      outbox.remove(p);
       return true;
     } catch (err) {
       p.attempts++;
       const next = afterFailure(err, p.attempts, RETRY);
       if (next.action === "park") {
         log.warn(`recordare: dropped ${p.req.messages.length} message(s) after ${p.attempts} attempt(s) (${next.reason}: ${errName(err)})`);
+        outbox.remove(p);
         return true;
       }
       if (queue.length >= MAX_QUEUE) {
-        queue.shift();
+        outbox.remove(queue.shift());
         log.warn("recordare: retry queue full, dropped the oldest batch");
       }
+      outbox.save(p);
       queue.push(p);
       schedule(next.delayMs);
       if (p.attempts === 1) log.warn(`recordare: ingest failed (${errName(err)}), retrying in the background`);
@@ -19739,7 +19937,7 @@ function registerRecordare(api, cfg, kinds) {
     for (const p of batch) await deliver(p);
   }
   function send(user, req) {
-    return deliver({ user, req, attempts: 0 });
+    return deliver({ id: pendingId(), user, req, attempts: 0 });
   }
   function who(ctx) {
     const key = ctx.sessionKey;
@@ -19766,6 +19964,8 @@ function registerRecordare(api, cfg, kinds) {
       source: "chat",
       channel: w.channel ? `openclaw:${w.channel}` : "openclaw",
       title: ctx.sessionKey,
+      // Group sessions are known by their key; every other session of a person is a direct chat (D51: link codes).
+      ...ctx.sessionKey ? { direct: !isGroupSession(ctx.sessionKey) } : {},
       participants
     };
   }
@@ -19787,6 +19987,10 @@ function registerRecordare(api, cfg, kinds) {
       const conversation = conversationMeta(w, ctx);
       const message = { externalId: `${id}:u`, role: w.speaker.role, authorRef: w.speaker.ref, content: clipUtf8(text), sentAt: now };
       remember(turns, ctx.runId ?? w.conversation, { user: w.user, conversation, message });
+      if (cfg.capture && isLinkCode(text)) {
+        void send(w.user, { conversation, messages: [message] });
+        return { prependSystemContext: LINK_CODE_INSTRUCTION };
+      }
       if (!cfg.capture) {
         const ctxRes = await fast.context(headerUser(w.user), w.conversation, text.slice(0, 4e3));
         return ctxRes.block ? { prependContext: ctxRes.block } : void 0;
@@ -19897,12 +20101,17 @@ function registerRecordare(api, cfg, kinds) {
       }, { name });
     }
   }
+  if (queue.length) {
+    log.info(`recordare: ${queue.length} undelivered batch(es) from the last run, retrying`);
+    schedule(RESUME_MS);
+  }
   return {
     async stop() {
       stopped = true;
       if (timer) clearTimeout(timer);
       timer = void 0;
-      await withTimeout(Promise.all(queue.splice(0).map((p) => slow.ingest(headerUser(p.user), p.req).catch(() => void 0))), 1500).catch(() => void 0);
+      const last = queue.splice(0);
+      await withTimeout(Promise.all(last.map((p) => slow.ingest(headerUser(p.user), p.req).then(() => outbox.remove(p), () => void 0))), 1500).catch(() => void 0);
       await Promise.all([fast.close(), slow.close()]).catch(() => void 0);
     }
   };
@@ -19919,11 +20128,12 @@ var index_default = definePluginEntry({
       api.logger.warn("recordare: not configured (set plugins.entries.recordare.config.url and apiKey); memory is off");
       return;
     }
+    const stateDir = api.runtime?.state?.resolveStateDir?.(process.env) || process.env.OPENCLAW_STATE_DIR?.trim() || join2(homedir(), ".openclaw");
     const plugin = registerRecordare(api, cfg, {
       isIncognito: (k) => !!k && isIncognitoSessionKey(k),
       isCron: (k) => !!k && isCronSessionKey(k),
       isSubagent: (k) => !!k && isSubagentSessionKey(k)
-    });
+    }, join2(stateDir, "recordare", "outbox"));
     api.registerService({ id: "recordare", start: () => void 0, stop: () => plugin.stop() });
   }
 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@arkimedehq/openclaw-recordare",
-  "version": "0.2.0",
+  "version": "0.4.0",
   "description": "Recordare for OpenClaw: long-term episodic memory kept by your own Recordare service (capture, recall before each turn, memory tools).",
   "license": "AGPL-3.0-or-later",
   "author": "Andrea Genovese",