@arkimedehq/openclaw-recordare 0.1.0 → 0.2.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (5) hide show
  1. package/README.md +56 -33
  2. package/README_it.md +60 -36
  3. package/dist/index.js +536 -186
  4. package/openclaw.plugin.json +27 -7
  5. package/package.json +1 -1
package/README.md CHANGED
@@ -5,19 +5,26 @@ own [Recordare](../../README.md) service — the **full** client level:
5
5
 
6
6
  - **Capture**: each message a person sends and each answer of the agent go to Recordare; when the OpenClaw session ends
7
7
  (`/new`, `/reset`, the daily or idle reset) Recordare extracts what happened, plans, facts and notes.
8
- - **Recall before each turn**: the memories relevant to the message are added before it as a fenced `<memory-context>`
9
- block (`POST api/v1/context`, no LLM call, nothing added when nothing is relevant).
8
+ - **Recall before each turn**: one call stores the message and returns the memories relevant to it, added before it as
9
+ a fenced `<memory-context>` block (`POST api/v1/context` with `ingest`, no LLM call, nothing added when nothing is
10
+ relevant).
10
11
  - **Memory tools**: `recordare_search_episodes`, `recordare_search_memory`, `recordare_resolve_period`,
11
- `recordare_remember`, `recordare_correct_episode`, `recordare_forget_episode` (Recordare's MCP tools, bound in code to
12
- the person and the conversation — neither the model nor the user can point them elsewhere). `log_episode` is left out:
13
- the conversation is already captured.
14
- - **Group chats**: the turns of known people are captured, with the other members' messages as context (role `other`).
15
- Recordare shows memories only when the viewers are exactly the owner, so recall stays empty in groups.
12
+ `recordare_remember`, `recordare_correct_episode`, `recordare_forget_episode`, `recordare_search_knowledge`,
13
+ `recordare_learn_source` (Recordare's MCP tools, bound in code to
14
+ the memory and the conversation — neither the model nor the user can point them elsewhere), with the schemas the
15
+ service publishes (`TOOLS` of the client library). `log_episode` is left out: the conversation is already captured.
16
+ - **One memory for the agent** (D50): the Gateway's agent has one memory; the people who talk to it — on any channel,
17
+ in direct chats and groups — are **participants** recognised inside it (each `<channel>:<senderId>` becomes a contact
18
+ of the memory, named after their channel name). You, the account holder, are the memory's "I". One memory per person
19
+ stays available (`memoryPer: "user"`).
20
+ - **Group chats**: every member's messages are captured with the turn that follows (other members as role `other`).
21
+ Recall works in groups too: Recordare answers with the whole memory in every conversation (D50: no viewer filter
22
+ for now — privacy and disclosure come later), so what the agent remembers can surface in front of the group.
16
23
 
17
- It does not take OpenClaw's memory slot: `memory-core` (`MEMORY.md`, `memory_search`) keeps working beside it. Nothing
18
- is stored until the Recordare admin switched the person's consent on. The plugin never blocks or breaks a turn: every
19
- call is time-boxed (3 s before the turn), failures are logged without content, captured messages that could not be sent
20
- are retried in the background for about ten minutes (in memory: a Gateway restart drops them).
24
+ It does not take OpenClaw's memory slot: `memory-core` (`MEMORY.md`, `memory_search`) keeps working beside it. Recordare
25
+ stores every turn the plugin sends (it has no consent flag, D50). The plugin never blocks or breaks a turn: every call
26
+ is time-boxed (3 s before the turn), failures are logged without content, captured messages that could not be sent are
27
+ retried in the background for about ten minutes (in memory: a Gateway restart drops them).
21
28
 
22
29
  Requires OpenClaw ≥ 2026.9.9 (Node ≥ 24, as OpenClaw itself).
23
30
 
@@ -30,12 +37,18 @@ Requires OpenClaw ≥ 2026.9.9 (Node ≥ 24, as OpenClaw itself).
30
37
  2. Or from a checkout (development): `cd connectors/openclaw && npm ci && npm run build`, then
31
38
  `openclaw plugins install --link /path/to/recordare/connectors/openclaw --accept-capabilities` (`--link` keeps it
32
39
  pointing at the folder; without it OpenClaw copies it). Restart the Gateway, then check
33
- `openclaw plugins inspect recordare --runtime --json` (status `loaded`, 4 hooks, 6 tools).
34
- 3. Ask the Recordare admin for a credential:
35
- - **one person** (your own assistant): a **personal token** with the scopes `mcp`, `ingest`, `read`
36
- (`POST api/v1/admin/owners/{id}/tokens`, client of kind `mcp_client`);
37
- - **several people**: a **client key** with the same scopes; each person is a client user (`X-Recordare-User`),
38
- known to Recordare or auto-provisioned if the client allows it.
40
+ `openclaw plugins inspect recordare --runtime --json` (status `loaded`, 4 hooks, 8 tools).
41
+ 3. Ask the Recordare admin for a credential for the agent's memory:
42
+ - a **personal token** with the scopes `mcp`, `ingest`, `read` (`POST api/v1/admin/memories/{id}/tokens`, client of
43
+ kind `mcp_client`) — the token's memory is the agent's;
44
+ - or a **client key** with the same scopes and the agent's account in `defaultUser` (a client user, known to
45
+ Recordare or auto-provisioned if the client allows it); a client key is also what one memory per person needs.
46
+
47
+ The memory's **mode** and **gender** are set by the admin (`PATCH api/v1/admin/memories/{id}` `{mode, gender}`), or
48
+ with a client key by `PATCH api/v1/me`: `personal` (your own assistant: you are "I", what arrives undeclared is
49
+ yours) or `entity` (an agent shared by a family, a team, a place: what arrives undeclared is "someone"'s); `gender`
50
+ `masculine` (default) | `feminine` | `neutral` for the first person in gendered languages. The plugin has no setting
51
+ for them.
39
52
  4. Configure it in `~/.openclaw/openclaw.json`:
40
53
  ```json5
41
54
  {
@@ -47,9 +60,9 @@ Requires OpenClaw ≥ 2026.9.9 (Node ≥ 24, as OpenClaw itself).
47
60
  hooks: { allowConversationAccess: true },
48
61
  config: {
49
62
  url: "http://localhost:8080",
50
- apiKey: "${RECORDARE_API_KEY}", // rp_… or rk_…; ${VAR} is read from the environment
51
- users: { "telegram:123456789": "alice" }, // "<channel>:<senderId>" → Recordare user
52
- defaultUser: "alice", // turns without a channel sender (CLI, Control UI)
63
+ apiKey: "${RECORDARE_API_KEY}", // rp_… or rk_…; ${VAR} is read from the environment
64
+ selfSenders: ["telegram:123456789"], // your own sender ids: you are the memory's "I"
65
+ // defaultUser: "my-agent", // with a client key: the agent's Recordare account
53
66
  },
54
67
  },
55
68
  },
@@ -64,36 +77,46 @@ Requires OpenClaw ≥ 2026.9.9 (Node ≥ 24, as OpenClaw itself).
64
77
  |---|---|---|
65
78
  | `url` | `RECORDARE_URL` | Recordare's address |
66
79
  | `apiKey` | `RECORDARE_API_KEY` | Client key (`rk_…`) or personal token (`rp_…`) |
67
- | `users` | `{}` | `"<channel>:<senderId>"` → Recordare user. Unmapped senders are not remembered |
68
- | `defaultUser` | — (`me` with a personal token) | User of turns without a channel sender |
80
+ | `memoryPer` | `agent` | `agent`: one memory for the agent, every sender a participant of it. `user`: one memory per person (`users`) |
81
+ | `defaultUser` | — (`me` with a personal token) | `agent`: the agent's Recordare account (client key; without it memory is off). `user`: the user of turns without a channel sender |
82
+ | `selfSenders` | `[]` | `agent`: the `"<channel>:<senderId>"` ids that are the account holder — the memory's "I". Turns without a channel sender (CLI, Control UI) are always theirs |
83
+ | `users` | `{}` | `user`: `"<channel>:<senderId>"` → Recordare user. Unmapped senders are not remembered |
69
84
  | `autoRecall` | `true` | Add the memory block before each turn |
70
85
  | `capture` | `true` | Send the conversations |
71
86
  | `tools` | `true` | Offer the `recordare_*` tools |
72
87
  | `groups` | `true` | Capture group chats too |
73
- | `timeoutMs` | `3000` | Per call before the turn (the message's ingest, then the context) |
88
+ | `timeoutMs` | `3000` | For the call before the turn (the message's ingest with its context) |
89
+
90
+ **Your own sender ids.** With `memoryPer: "agent"` a sender not in `selfSenders` is somebody the agent knows, not you:
91
+ list your ids there (or have the admin bind them to the memory's self, `POST api/v1/admin/identities`
92
+ `{kind: "participant", memoryId, personId: <the memory>, channel, externalId}`, before you first write). Other
93
+ people's words are kept as theirs (role `other`, attributed to their contact), so what they say about themselves never
94
+ becomes a fact about you.
74
95
 
75
- With a personal token and an empty `users` map every turn belongs to the token's person (a single-person install). If
76
- other people can talk to the agent, map your own sender ids in `users`: everyone else is then left out.
96
+ **Upgrading from a `users` map.** The earlier behaviour (each mapped sender a separate Recordare user, unmapped senders
97
+ not remembered) is `memoryPer: "user"`: add it to keep your memories split per person.
77
98
 
78
99
  ### Several people on one Gateway
79
- OpenClaw's default `session.dmScope: "main"` puts **all direct messages of all people into one session**, so one
80
- person's turns would land in another's conversation context. Set
100
+ OpenClaw's default `session.dmScope: "main"` puts **all direct messages of all people into one session**. Every message
101
+ is still attributed to its sender, but the agent sees one person's turns in another's context. Set
81
102
  ```json5
82
103
  { session: { dmScope: "per-channel-peer" } }
83
104
  ```
84
- (or `per-peer` with `session.identityLinks` for people who write from several channels) and map every person in
85
- `users`. Check with `openclaw security audit`.
105
+ (or `per-peer` with `session.identityLinks` for people who write from several channels). Check with
106
+ `openclaw security audit`. Recordare answers with the whole memory in every conversation (D50): what one person told
107
+ the agent can come up with another; whoever runs the Gateway tells the people who talk to it.
86
108
 
87
109
  ## How it maps
88
110
 
89
111
  | OpenClaw | Recordare |
90
112
  |---|---|
91
113
  | session (key + session id) | conversation `openclaw:<sessionKey>/<sessionId>` (channel `openclaw:<channel>`, title = session key) |
92
- | `<channel>:<senderId>` (`users`), or `defaultUser` | the user (`X-Recordare-User` with a client key; the token's person otherwise) |
93
- | the person's message (`before_prompt_build`) | message `user`, id `<currentUserMessageId or runId>:u`, sent **before** the agent runs (so what the agent stores with `recordare_remember` binds to the person's own words) |
114
+ | the agent (`memoryPer: agent`) — or `<channel>:<senderId>` (`users`) / `defaultUser` (`memoryPer: user`) | the memory (`X-Recordare-User` with a client key; the token's memory otherwise) |
115
+ | a sender (`memoryPer: agent`) | the account holder (`selfSenders`, CLI, Control UI): participant `holder`, message `user`; anyone else: participant `<channel>:<senderId>` with the channel identity `{channel, externalId: senderId}` and their channel name (from `message_received`), message `other` — Recordare links it to a contact of the memory, created on first sight |
116
+ | the person's message (`before_prompt_build`) | message (as above), id `<currentUserMessageId or runId>:u`, stored **before** the agent runs, in the same call that returns the memory block (so what the agent stores with `recordare_remember` binds to the person's own words); a plain ingest when `autoRecall` is off |
94
117
  | the agent's text after it (`agent_end`) | message `assistant`, id `<runId>:a` (tool calls and results are not sent) |
95
- | other members' messages in a group (`message_received`) | messages `other`, author `<channel>:<senderId>` (participant with a channel identity) |
96
- | session end (`session_end`: new, reset, idle, daily, deleted) | `conversationEnded` → extraction now instead of after the idle delay (not on compaction, shutdown or restart) |
118
+ | other members' messages in a group (`message_received`) | messages `other`, author `<channel>:<senderId>` (participant with a channel identity); the account holder's own as `user` (`memoryPer: agent`) |
119
+ | session end (`session_end`: new, reset, idle, daily, deleted) | `POST api/v1/ingest/conversations/{id}/end` → extraction now instead of after the idle delay (not on compaction, shutdown or restart) |
97
120
  | memory block | `prependContext` of `before_prompt_build` (model-only in OpenClaw; never sent back to Recordare — the plugin strips it) |
98
121
  | cron, heartbeat, sub-agent, agent-to-agent and incognito runs | not remembered |
99
122
 
package/README_it.md CHANGED
@@ -6,21 +6,28 @@ tenuta dal tuo servizio [Recordare](../../README_it.md) — il livello client **
6
6
  - **Cattura**: ogni messaggio di una persona e ogni risposta dell'agente vanno a Recordare; quando la sessione di
7
7
  OpenClaw finisce (`/new`, `/reset`, il reset giornaliero o per inattività) Recordare estrae ciò che è successo, piani,
8
8
  fatti e note.
9
- - **Richiamo prima di ogni turno**: i ricordi rilevanti per il messaggio vengono aggiunti prima di esso in un blocco
10
- delimitato `<memory-context>` (`POST api/v1/context`, nessuna chiamata LLM, nulla se nulla è rilevante).
9
+ - **Richiamo prima di ogni turno**: una sola chiamata salva il messaggio e restituisce i ricordi rilevanti, aggiunti prima
10
+ di esso in un blocco delimitato `<memory-context>` (`POST api/v1/context` con `ingest`, nessuna chiamata LLM, nulla se
11
+ nulla è rilevante).
11
12
  - **Strumenti di memoria**: `recordare_search_episodes`, `recordare_search_memory`, `recordare_resolve_period`,
12
- `recordare_remember`, `recordare_correct_episode`, `recordare_forget_episode` (gli strumenti MCP di Recordare, legati
13
- nel codice alla persona e alla conversazione — né il modello né l'utente possono puntarli altrove). `log_episode` è
14
- escluso: la conversazione è già catturata.
15
- - **Chat di gruppo**: si catturano i turni delle persone note, con i messaggi degli altri membri come contesto (ruolo
16
- `other`). Recordare mostra i ricordi solo quando chi li vede è esattamente il proprietario, quindi nei gruppi il
17
- richiamo resta vuoto.
18
-
19
- Non occupa lo slot memoria di OpenClaw: `memory-core` (`MEMORY.md`, `memory_search`) continua a funzionare accanto. Nulla
20
- viene salvato finché l'amministratore di Recordare non ha attivato il consenso della persona. Il plugin non blocca né
21
- rompe mai un turno: ogni chiamata ha un limite di tempo (3 s prima del turno), gli errori finiscono nel log senza
22
- contenuti, i messaggi catturati non inviati vengono ritentati in background per una decina di minuti (in memoria: un
23
- riavvio del Gateway li perde).
13
+ `recordare_remember`, `recordare_correct_episode`, `recordare_forget_episode`, `recordare_search_knowledge`,
14
+ `recordare_learn_source` (gli strumenti MCP di Recordare, legati
15
+ nel codice alla memoria e alla conversazione — né il modello né l'utente possono puntarli altrove), con gli schemi
16
+ pubblicati dal servizio (`TOOLS` della libreria client). `log_episode` è escluso: la conversazione è già catturata.
17
+ - **Una memoria per l'agente** (D50): l'agente del Gateway ha una sola memoria; le persone che gli parlano — su qualsiasi
18
+ canale, in chat dirette e gruppi — sono **partecipanti** riconosciuti al suo interno (ogni `<canale>:<senderId>`
19
+ diventa un contatto della memoria, con il nome che ha sul canale). Tu, il titolare dell'account, sei l'"io" della
20
+ memoria. Una memoria per persona resta disponibile (`memoryPer: "user"`).
21
+ - **Chat di gruppo**: si catturano i messaggi di tutti i membri insieme al turno che segue (gli altri membri con ruolo
22
+ `other`). Il richiamo funziona anche nei gruppi: Recordare risponde con tutta la memoria in ogni conversazione (D50:
23
+ per ora nessun filtro su chi legge — privacy e riservatezza verranno dopo), quindi ciò che l'agente ricorda può
24
+ emergere davanti al gruppo.
25
+
26
+ Non occupa lo slot memoria di OpenClaw: `memory-core` (`MEMORY.md`, `memory_search`) continua a funzionare accanto.
27
+ Recordare conserva ogni turno che il plugin invia (non ha un flag di consenso, D50). Il plugin non blocca né rompe mai
28
+ un turno: ogni chiamata ha un limite di tempo (3 s prima del turno), gli errori finiscono nel log senza contenuti, i
29
+ messaggi catturati non inviati vengono ritentati in background per una decina di minuti (in memoria: un riavvio del
30
+ Gateway li perde).
24
31
 
25
32
  Richiede OpenClaw ≥ 2026.9.9 (Node ≥ 24, come OpenClaw stesso).
26
33
 
@@ -33,12 +40,19 @@ Richiede OpenClaw ≥ 2026.9.9 (Node ≥ 24, come OpenClaw stesso).
33
40
  2. Oppure da un checkout (sviluppo): `cd connectors/openclaw && npm ci && npm run build`, poi
34
41
  `openclaw plugins install --link /percorso/di/recordare/connectors/openclaw --accept-capabilities` (`--link` lo
35
42
  lascia puntato alla cartella; senza, OpenClaw lo copia). Riavvia il Gateway, poi controlla
36
- `openclaw plugins inspect recordare --runtime --json` (stato `loaded`, 4 hook, 6 strumenti).
37
- 3. Chiedi all'amministratore di Recordare una credenziale:
38
- - **una persona** (il tuo assistente): un **token personale** con gli scope `mcp`, `ingest`, `read`
39
- (`POST api/v1/admin/owners/{id}/tokens`, client di tipo `mcp_client`);
40
- - **più persone**: una **chiave client** con gli stessi scope; ogni persona è un utente del client
41
- (`X-Recordare-User`), noto a Recordare o creato automaticamente se il client lo consente.
43
+ `openclaw plugins inspect recordare --runtime --json` (stato `loaded`, 4 hook, 8 strumenti).
44
+ 3. Chiedi all'amministratore di Recordare una credenziale per la memoria dell'agente:
45
+ - un **token personale** con gli scope `mcp`, `ingest`, `read` (`POST api/v1/admin/memories/{id}/tokens`, client di
46
+ tipo `mcp_client`) — la memoria del token è quella dell'agente;
47
+ - oppure una **chiave client** con gli stessi scope e l'account dell'agente in `defaultUser` (un utente del client,
48
+ noto a Recordare o creato automaticamente se il client lo consente); la chiave client serve anche per una memoria
49
+ per persona.
50
+
51
+ **Modalità** e **genere** della memoria li imposta l'amministratore (`PATCH api/v1/admin/memories/{id}`
52
+ `{mode, gender}`), oppure, con una chiave client, `PATCH api/v1/me`: `personal` (il tuo assistente: tu sei l'"io",
53
+ ciò che arriva senza identità dichiarata è tuo) o `entity` (un agente condiviso da una famiglia, un team, un luogo:
54
+ ciò che arriva senza identità è di "qualcuno"); `gender` `masculine` (default) | `feminine` | `neutral` per la prima
55
+ persona nelle lingue con il genere. Il plugin non ha impostazioni per questi valori.
42
56
  4. Configuralo in `~/.openclaw/openclaw.json`:
43
57
  ```json5
44
58
  {
@@ -50,9 +64,9 @@ Richiede OpenClaw ≥ 2026.9.9 (Node ≥ 24, come OpenClaw stesso).
50
64
  hooks: { allowConversationAccess: true },
51
65
  config: {
52
66
  url: "http://localhost:8080",
53
- apiKey: "${RECORDARE_API_KEY}", // rp_… o rk_…; ${VAR} viene letta dall'ambiente
54
- users: { "telegram:123456789": "alice" }, // "<canale>:<senderId>" → utente Recordare
55
- defaultUser: "alice", // turni senza mittente di canale (CLI, Control UI)
67
+ apiKey: "${RECORDARE_API_KEY}", // rp_… o rk_…; ${VAR} viene letta dall'ambiente
68
+ selfSenders: ["telegram:123456789"], // i tuoi sender id: sei l'"io" della memoria
69
+ // defaultUser: "il-mio-agente", // con una chiave client: l'account Recordare dell'agente
56
70
  },
57
71
  },
58
72
  },
@@ -67,37 +81,47 @@ Richiede OpenClaw ≥ 2026.9.9 (Node ≥ 24, come OpenClaw stesso).
67
81
  |---|---|---|
68
82
  | `url` | `RECORDARE_URL` | Indirizzo di Recordare |
69
83
  | `apiKey` | `RECORDARE_API_KEY` | Chiave client (`rk_…`) o token personale (`rp_…`) |
70
- | `users` | `{}` | `"<canale>:<senderId>"` → utente Recordare. I mittenti non mappati non vengono ricordati |
71
- | `defaultUser` | — (`me` con un token personale) | Utente dei turni senza mittente di canale |
84
+ | `memoryPer` | `agent` | `agent`: una memoria per l'agente, ogni mittente è un suo partecipante. `user`: una memoria per persona (`users`) |
85
+ | `defaultUser` | — (`me` con un token personale) | `agent`: l'account Recordare dell'agente (chiave client; senza, la memoria è spenta). `user`: l'utente dei turni senza mittente di canale |
86
+ | `selfSenders` | `[]` | `agent`: gli id `"<canale>:<senderId>"` del titolare dell'account — l'"io" della memoria. I turni senza mittente di canale (CLI, Control UI) sono sempre suoi |
87
+ | `users` | `{}` | `user`: `"<canale>:<senderId>"` → utente Recordare. I mittenti non mappati non vengono ricordati |
72
88
  | `autoRecall` | `true` | Aggiunge il blocco di memoria prima di ogni turno |
73
89
  | `capture` | `true` | Invia le conversazioni |
74
90
  | `tools` | `true` | Offre gli strumenti `recordare_*` |
75
91
  | `groups` | `true` | Cattura anche le chat di gruppo |
76
- | `timeoutMs` | `3000` | Per chiamata prima del turno (l'invio del messaggio, poi il contesto) |
92
+ | `timeoutMs` | `3000` | Per la chiamata prima del turno (l'invio del messaggio con il suo contesto) |
93
+
94
+ **I tuoi sender id.** Con `memoryPer: "agent"` un mittente che non è in `selfSenders` è qualcuno che l'agente conosce,
95
+ non tu: elenca lì i tuoi id (oppure chiedi all'amministratore di legarli al sé della memoria,
96
+ `POST api/v1/admin/identities` `{kind: "participant", memoryId, personId: <la memoria>, channel, externalId}`, prima
97
+ di scrivere la prima volta). Le parole degli altri restano loro (ruolo `other`, attribuite al loro contatto), così ciò
98
+ che dicono di sé non diventa mai un fatto su di te.
77
99
 
78
- Con un token personale e la mappa `users` vuota ogni turno appartiene alla persona del token (installazione per una
79
- persona). Se altre persone possono parlare con l'agente, mappa i tuoi sender id in `users`: tutti gli altri restano
80
- fuori.
100
+ **Aggiornare da una mappa `users`.** Il comportamento precedente (ogni mittente mappato un utente Recordare separato, i
101
+ non mappati non ricordati) è `memoryPer: "user"`: aggiungilo per tenere le memorie divise per persona.
81
102
 
82
103
  ### Più persone sullo stesso Gateway
83
104
  Il default di OpenClaw `session.dmScope: "main"` mette **tutti i messaggi diretti di tutte le persone in un'unica
84
- sessione**, quindi i turni di una persona finirebbero nel contesto di conversazione di un'altra. Imposta
105
+ sessione**. Ogni messaggio resta attribuito al suo mittente, ma l'agente vede i turni di una persona nel contesto di
106
+ un'altra. Imposta
85
107
  ```json5
86
108
  { session: { dmScope: "per-channel-peer" } }
87
109
  ```
88
- (oppure `per-peer` con `session.identityLinks` per chi scrive da più canali) e mappa ogni persona in `users`. Verifica
89
- con `openclaw security audit`.
110
+ (oppure `per-peer` con `session.identityLinks` per chi scrive da più canali). Verifica con `openclaw security audit`.
111
+ Recordare risponde con tutta la memoria in ogni conversazione (D50): ciò che una persona ha detto all'agente può
112
+ emergere con un'altra; chi gestisce il Gateway lo dice alle persone che gli parlano.
90
113
 
91
114
  ## Corrispondenze
92
115
 
93
116
  | OpenClaw | Recordare |
94
117
  |---|---|
95
118
  | sessione (chiave + session id) | conversazione `openclaw:<sessionKey>/<sessionId>` (canale `openclaw:<canale>`, titolo = chiave di sessione) |
96
- | `<canale>:<senderId>` (`users`), oppure `defaultUser` | l'utente (`X-Recordare-User` con una chiave client; altrimenti la persona del token) |
97
- | il messaggio della persona (`before_prompt_build`) | messaggio `user`, id `<currentUserMessageId o runId>:u`, inviato **prima** che l'agente parta (così ciò che l'agente salva con `recordare_remember` si lega alle parole della persona) |
119
+ | l'agente (`memoryPer: agent`) — oppure `<canale>:<senderId>` (`users`) / `defaultUser` (`memoryPer: user`) | la memoria (`X-Recordare-User` con una chiave client; altrimenti la memoria del token) |
120
+ | un mittente (`memoryPer: agent`) | il titolare dell'account (`selfSenders`, CLI, Control UI): partecipante `holder`, messaggio `user`; chiunque altro: partecipante `<canale>:<senderId>` con l'identità di canale `{channel, externalId: senderId}` e il nome che ha sul canale (da `message_received`), messaggio `other` — Recordare lo lega a un contatto della memoria, creato alla prima occasione |
121
+ | il messaggio della persona (`before_prompt_build`) | messaggio (come sopra), id `<currentUserMessageId o runId>:u`, salvato **prima** che l'agente parta, nella stessa chiamata che restituisce il blocco di memoria (così ciò che l'agente salva con `recordare_remember` si lega alle parole della persona); un semplice ingest se `autoRecall` è spento |
98
122
  | il testo dell'agente che segue (`agent_end`) | messaggio `assistant`, id `<runId>:a` (chiamate e risultati degli strumenti non vengono inviati) |
99
- | messaggi degli altri membri di un gruppo (`message_received`) | messaggi `other`, autore `<canale>:<senderId>` (partecipante con identità di canale) |
100
- | fine sessione (`session_end`: new, reset, idle, daily, deleted) | `conversationEnded` → estrazione subito invece che dopo il ritardo di inattività (non su compaction, shutdown o restart) |
123
+ | messaggi degli altri membri di un gruppo (`message_received`) | messaggi `other`, autore `<canale>:<senderId>` (partecipante con identità di canale); quelli del titolare dell'account come `user` (`memoryPer: agent`) |
124
+ | fine sessione (`session_end`: new, reset, idle, daily, deleted) | `POST api/v1/ingest/conversations/{id}/end` → estrazione subito invece che dopo il ritardo di inattività (non su compaction, shutdown o restart) |
101
125
  | blocco di memoria | `prependContext` di `before_prompt_build` (solo per il modello in OpenClaw; mai rimandato a Recordare — il plugin lo rimuove) |
102
126
  | esecuzioni cron, heartbeat, sub-agente, tra agenti e incognito | non ricordate |
103
127