@joe-broadhead/opencode-mem 0.9.12 → 0.11.2

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 (144) hide show
  1. package/CHANGELOG.md +1934 -2
  2. package/README.md +29 -17
  3. package/SECURITY.md +3 -1
  4. package/docs/agent-instructions.md +17 -0
  5. package/docs/agent-protocol.md +8 -8
  6. package/docs/permissions.md +22 -4
  7. package/package.json +7923 -217
  8. package/shared/page-paths.js +44 -0
  9. package/skills/mem.pages/SKILL.md +8 -1
  10. package/skills/mem.usage/SKILL.md +15 -15
  11. package/src/action-grant-keys.js +159 -0
  12. package/src/action-grant.js +439 -0
  13. package/src/actions.js +1690 -0
  14. package/src/backend/records.js +25 -2
  15. package/src/backend/v3.js +76 -22
  16. package/src/call-shapes.js +17 -16
  17. package/src/collector-lock.js +533 -62
  18. package/src/collector-service.js +153 -26
  19. package/src/collector.js +627 -33
  20. package/src/config.js +79 -6
  21. package/src/connect.js +106 -8
  22. package/src/credentials.js +123 -25
  23. package/src/events.js +174 -3
  24. package/src/forget-turn.js +141 -0
  25. package/src/host-refusal.js +78 -0
  26. package/src/index.js +209 -22
  27. package/src/jobs/host.js +557 -0
  28. package/src/ops/codes.js +110 -0
  29. package/src/ops/copy-lineage.js +42 -0
  30. package/src/ops/index.js +28 -0
  31. package/src/ops/space-ops.js +1936 -0
  32. package/src/outlinks.js +103 -0
  33. package/src/p2-reservation.js +151 -0
  34. package/src/permissions.js +30 -0
  35. package/src/plugins/descriptor.js +62 -0
  36. package/src/plugins/discovery.js +318 -0
  37. package/src/plugins/grants.js +178 -0
  38. package/src/plugins/locate.js +319 -0
  39. package/src/plugins/manifest.js +1162 -0
  40. package/src/plugins/source-contract/index.js +34 -0
  41. package/src/plugins/source-contract/policy.js +102 -0
  42. package/src/plugins/source-contract/vendor/PROVENANCE.json +17 -0
  43. package/src/plugins/source-contract/vendor/RELEASE-SHA256SUMS +3 -0
  44. package/src/plugins/source-contract/vendor/RELEASE.json +17 -0
  45. package/src/plugins/source-contract/vendor/SHA256SUMS +41 -0
  46. package/src/plugins/source-contract/vendor/THIRD-PARTY-NOTICES.md +35 -0
  47. package/src/plugins/source-contract/vendor/broker-client.js +93 -0
  48. package/src/plugins/source-contract/vendor/chunks/chunk-3M5PAKSS.js +84 -0
  49. package/src/plugins/source-contract/vendor/chunks/chunk-4ERCA4TK.js +185 -0
  50. package/src/plugins/source-contract/vendor/chunks/chunk-6HDIB2SA.js +183 -0
  51. package/src/plugins/source-contract/vendor/chunks/chunk-ELPJD3ND.js +10 -0
  52. package/src/plugins/source-contract/vendor/chunks/chunk-HLVAKAYG.js +10 -0
  53. package/src/plugins/source-contract/vendor/chunks/chunk-I2RXJJJM.js +81 -0
  54. package/src/plugins/source-contract/vendor/chunks/chunk-KWEWSZ4V.js +505 -0
  55. package/src/plugins/source-contract/vendor/chunks/chunk-KYWBTAF4.js +182 -0
  56. package/src/plugins/source-contract/vendor/chunks/chunk-Q3RQA5J2.js +249 -0
  57. package/src/plugins/source-contract/vendor/chunks/chunk-RRUAIQ4I.js +156 -0
  58. package/src/plugins/source-contract/vendor/chunks/chunk-RYNKNCPP.js +165 -0
  59. package/src/plugins/source-contract/vendor/chunks/chunk-W5SHR7DQ.js +9477 -0
  60. package/src/plugins/source-contract/vendor/chunks/chunk-ZUKF7P6U.js +653 -0
  61. package/src/plugins/source-contract/vendor/cursor.js +26 -0
  62. package/src/plugins/source-contract/vendor/descriptor.js +34 -0
  63. package/src/plugins/source-contract/vendor/events.js +257 -0
  64. package/src/plugins/source-contract/vendor/index.js +10 -0
  65. package/src/plugins/source-contract/vendor/params.js +22 -0
  66. package/src/plugins/source-contract/vendor/permission.js +28 -0
  67. package/src/plugins/source-contract/vendor/pick.js +22 -0
  68. package/src/plugins/source-contract/vendor/read.js +29 -0
  69. package/src/plugins/source-contract/vendor/registry.js +23 -0
  70. package/src/plugins/source-contract/vendor/schema.js +17 -0
  71. package/src/plugins/source-contract/vendor/schemas/output.agenda.json +96 -0
  72. package/src/plugins/source-contract/vendor/schemas/output.countdown.json +28 -0
  73. package/src/plugins/source-contract/vendor/schemas/output.image.json +28 -0
  74. package/src/plugins/source-contract/vendor/schemas/output.inbox.json +84 -0
  75. package/src/plugins/source-contract/vendor/schemas/output.links.json +46 -0
  76. package/src/plugins/source-contract/vendor/schemas/output.list.json +57 -0
  77. package/src/plugins/source-contract/vendor/schemas/output.metric.json +61 -0
  78. package/src/plugins/source-contract/vendor/schemas/output.note.json +14 -0
  79. package/src/plugins/source-contract/vendor/schemas/output.progress.json +50 -0
  80. package/src/plugins/source-contract/vendor/schemas/output.record.json +38 -0
  81. package/src/plugins/source-contract/vendor/schemas/output.table.json +61 -0
  82. package/src/plugins/source-contract/vendor/schemas/output.thread.json +62 -0
  83. package/src/plugins/source-contract/vendor/schemas/sources.json +819 -0
  84. package/src/plugins/source-contract/vendor/schemas.js +19 -0
  85. package/src/plugins/source-contract/vendor/tools-rpc.js +42 -0
  86. package/src/plugins/verify.js +56 -0
  87. package/src/protocol.js +21 -5
  88. package/src/recall.js +104 -5
  89. package/src/records.js +61 -2
  90. package/src/requests.js +216 -0
  91. package/src/runtime.js +89 -7
  92. package/src/setup-time.js +68 -0
  93. package/src/skills.js +230 -8
  94. package/src/source-ids.js +25 -0
  95. package/src/sources/declaration.js +365 -0
  96. package/src/sources/reads.js +772 -0
  97. package/src/sources/rpc.js +151 -0
  98. package/src/sources.js +409 -90
  99. package/src/spaces.js +283 -11
  100. package/src/spool.js +61 -4
  101. package/src/stated.js +10 -5
  102. package/src/storable.js +139 -0
  103. package/src/tools/commitments.js +47 -5
  104. package/src/tools/held-write.js +36 -13
  105. package/src/tools/index.js +27 -0
  106. package/src/tools/ingest.js +27 -2
  107. package/src/tools/memory.js +52 -14
  108. package/src/tools/page.js +95 -9
  109. package/src/tools/recall.js +208 -4
  110. package/src/tools/records-kit.js +2 -1
  111. package/src/tools/share.js +42 -3
  112. package/src/tools/shared.js +44 -4
  113. package/src/tools/space-lifecycle.js +278 -0
  114. package/src/tools/spaces.js +373 -29
  115. package/src/tools/status.js +9 -2
  116. package/src/tools/wiki.js +34 -4
  117. package/src/util.js +110 -6
  118. package/src/vendor/source-contract/README.md +24 -0
  119. package/src/vendor/source-contract/THIRD-PARTY-NOTICES.md +35 -0
  120. package/src/vendor/source-contract/VENDOR.json +81 -0
  121. package/src/vendor/source-contract/chunks/chunk-3M5PAKSS.js +84 -0
  122. package/src/vendor/source-contract/chunks/chunk-6HDIB2SA.js +183 -0
  123. package/src/vendor/source-contract/chunks/chunk-HLVAKAYG.js +10 -0
  124. package/src/vendor/source-contract/chunks/chunk-I2RXJJJM.js +81 -0
  125. package/src/vendor/source-contract/chunks/chunk-KWEWSZ4V.js +505 -0
  126. package/src/vendor/source-contract/chunks/chunk-W5SHR7DQ.js +9477 -0
  127. package/src/vendor/source-contract/chunks/chunk-ZUKF7P6U.js +653 -0
  128. package/src/vendor/source-contract/cursor.js +26 -0
  129. package/src/vendor/source-contract/events.js +257 -0
  130. package/src/vendor/source-contract/registry.js +23 -0
  131. package/src/vendor/source-contract/tools-rpc.js +42 -0
  132. package/src/views/access-reads.js +256 -0
  133. package/src/views/communities.js +77 -0
  134. package/src/views/contracts.js +1183 -36
  135. package/src/views/inbox-bytes.js +103 -0
  136. package/src/views/overdue.js +1 -1
  137. package/src/views/profile.js +31 -0
  138. package/src/views/receipt.js +81 -0
  139. package/src/views/records-reads.js +869 -37
  140. package/src/views/rpc.js +159 -11
  141. package/src/views/shape.js +8 -5
  142. package/views/memory.html +16 -3
  143. package/views/pages.html +2 -2
  144. package/views/remembered.html +130 -0
package/CHANGELOG.md CHANGED
@@ -3,6 +3,1934 @@
3
3
  The format follows Keep a Changelog 1.1.0: one `## [x.y.z] - date` section per
4
4
  release.
5
5
 
6
+ ## [0.11.2] - 2026-11-16
7
+
8
+ Includes every change listed under 0.11.1 and 0.11.0, and this fix:
9
+
10
+ ### Fixed
11
+
12
+ - A recall in a shared space now also counts the person's own private matches for the
13
+ same query and states the count, without showing them. An agent no longer has only a
14
+ warning that private memory was not searched.
15
+
16
+ ## [0.11.1] - 2026-11-16
17
+
18
+ Not released: it did not pass its release gate. In one attempt, after searching only a
19
+ shared space, the agent told the person their own notes held nothing on a topic that a
20
+ private note covered. Its changes ship in 0.11.2.
21
+
22
+ Includes every change listed under 0.11.0, and this fix:
23
+
24
+ ### Fixed
25
+
26
+ - A commitment the agent saves keeps a due date or a trigger only when the person's
27
+ own messages name it. Otherwise it is saved without one, and the answer says to
28
+ ask the person. A press with no call id, in a session with no person message,
29
+ keeps them, as before.
30
+
31
+ ## [0.11.0] - 2026-11-15
32
+
33
+ Not released: it did not pass its release gate. In one attempt, the agent saved a
34
+ commitment with a condition the person never stated. Its changes ship in 0.11.1.
35
+
36
+ **0.11 is not released**, and `package.json` stays at 0.10.2 until its release
37
+ commit. **0.10.4 and 0.10.5 were never released:** 0.10.4 was a candidate whose
38
+ gate found two wrong answers about what memory holds, and 0.10.5 was the
39
+ candidate that fixed them and passed its own gate; neither was published, and
40
+ both sections are kept below as history, marked not released. 0.10.5's
41
+ candidate is in this tree — it was merged in at `3ac0fa5b` — so everything they
42
+ carry ships here. This section is what `build/0.11` merges: reviewed lanes
43
+ whose entries were written in their own branches and are combined here, in one
44
+ section, without a version bump — the space and sharing acts (#58 A2–A9, A11),
45
+ control's P2, console parity (#59 §4.5), the source contract, Memory as a
46
+ source provider (#58 §B), Memory Jobs' schedule and shared budget, the
47
+ spaces-to-join read, 0.10.2's three Jelly reads, Plan A's declared actions, a
48
+ person's erasure when Jelly ID deletes their account, a removed file retracting
49
+ what it caused, one collector per cell, source reads through Jelly's broker (off
50
+ until source-contract #8), and Jelly's own sheet, read-only page and wiki twins
51
+ and tiles (#55 and #72–#75).
52
+
53
+ **Jelly 0.4.0-beta.20 or newer (protocol major 7) is required.** The
54
+ declaration carries 34 actions; an older Jelly caps a plugin at 32 and refuses
55
+ the whole declaration with a schema error (`actions: Too big: expected array to
56
+ have <=32 items`), so Memory 0.11 does not load there. `requires` has no
57
+ feature name for the 48-action cap, so the refusal is a schema error rather
58
+ than "needs a newer Jelly".
59
+
60
+ **0.10.4 to 0.10.7 were never released:** 0.10.4 to 0.10.6 keep their own
61
+ sections below, each marked not released, and 0.11 carries all four releases’
62
+ changes.
63
+
64
+ ### Security
65
+
66
+ - **Your jelly sign-in token now goes only to the Memory service it was issued for.** If Memory's address points at another server, Memory uses your `/connect` sign-in or the key you pasted instead, and never hands that other server your jelly token. If neither is set, Memory tells you to run `/connect`.
67
+
68
+ - **Inside Jelly, with an address of one's own, the person's Jelly identity
69
+ token went to that address; from 0.11 it only ever goes to Jelly's own
70
+ origin** (`jelly-declarations` review R2-B1). With the switch on and a
71
+ service address of one's own configured, `createCredentials` minted the Jelly
72
+ identity token first and sent it there: a token that names the person, carries
73
+ no `cnf`, and lives ten minutes, so whoever operated that address could replay
74
+ it against Jelly's Memory — and the person's own key was never used.
75
+ `createCredentials` now takes `identityAllowed`, which `src/index.js` passes
76
+ `false` whenever `insideJelly && ownService`, so an address of one's own is
77
+ reached only by the person's key or `/connect` and Jelly's token only ever
78
+ goes to the origin Jelly offers. **Exposure is low:** before 0.11 such an
79
+ address could come only from a config file. Test:
80
+ `JD-switch-on-own-address-never-jelly-token`.
81
+ - **A source's, a plugin's and a job's own failure text is redacted wherever it
82
+ is stored or shown; before 0.11 it was stored raw and displayed verbatim.**
83
+ A probe or a paused bind stored `refresh_token=…`, `token=tk_…` and
84
+ `Bearer sk-live-…` in `source_requests.note`, `source_collections.error`,
85
+ `plugin_consents.reason`, `job_runs.refusals`, `job_logs.detail` and
86
+ `collector.json` — the status file every process reads — and `sources.list`,
87
+ `mem_spaces` health and the console showed them. Slicing to 100 or 300
88
+ characters protects nothing. Every one of those paths now goes through the
89
+ shared `storable.js` redactor **where it is written**, and the records service
90
+ redacts again as it answers `sources.list`, `jobs.runs`, `jobs.logs`,
91
+ `jobs.list`, `plugin_consents.reason` and `plugin_requests.note`, so a row an
92
+ older build wrote cannot show a secret through any reader, the console
93
+ included; `collector.json` is redacted field by field as it is written.
94
+ Tests: `RS-pause-reason-redacted`, `RS-refusal-reason-redacted`,
95
+ `RS-status-file-redacted`, `RS-status-held-redacted`,
96
+ `RS-job-checkpoint-redacted`, `RS-old-source-rows-redacted-on-read`.
97
+ - **Routine model errors are redacted too, and the daily journal's line with
98
+ them; the routine paths kept that text raw, the journal line since 0.9.14.**
99
+ A provider error can quote a key or a URL with a token, and `runs.run.error`
100
+ (and its `result`), the `memory.routine.llm` log line and the journal page's
101
+ "The model failed on part of the day (…)" each carried it — into a page that
102
+ is full-text indexed and shown by the console, a log, and `listRuns`,
103
+ `routines.status` and `space.stats` (`last_runs`), which the console's Home,
104
+ Spaces and Activity and `mem_spaces` health read. The shared redactor now runs
105
+ where the run finishes and again in the records service on write (`putRun`)
106
+ and on read, so an old row cannot show one either. Journals written before
107
+ this fix are **not** rewritten — an ordinary page's body is the person's own
108
+ text — and the line keeps the fixed prefix above, so it can be found and
109
+ redacted, or the person can edit the page. Tests:
110
+ `RS-daily-llm-error-redacted`, `RS-routine-llm-error-redacted`.
111
+ - **The skill mirror is bound to the account and the origin it was mirrored
112
+ for.** `skill.json` records both beside the mirrored `SKILL.md`, so signed
113
+ out, signed in as someone else, or on another server, no cached skill is
114
+ registered and a previous account's private skills never come back. Tests:
115
+ `JU-cache-not-used-after-sign-out`, `JU-cache-not-used-for-another-account`
116
+ (the whole change, with its measurements and deadlines, is **A start no
117
+ longer waits for the skill mirror** under Fixed).
118
+
119
+ ### Added
120
+
121
+ - **A meeting's page carries its transcript, and a review row names its meeting
122
+ (0.11, jelly's #61 and #62, the fields and the read).** `page.save` takes
123
+ `transcript` and keeps it in `fields.transcript`, the field the meeting engine
124
+ reads (`records/src/jobs/meetings.js`), and declares the `path` and `type` its
125
+ answer already carried, so a host can save the same meeting's page again. One
126
+ meeting has one page: a save that names no path lands at `meetings/<meeting
127
+ id>` whatever the page is called, and a second save of the same meeting updates
128
+ that page and adds a version instead of writing a second one; a page that
129
+ lives at the path and is another meeting's is refused, as before. A page's
130
+ `fields` take 32 KiB in the records service and the meeting's fields ride
131
+ there too, so `transcript` is held to 16 KiB of **UTF-8 bytes** (the declared
132
+ `maxLength` is that figure in characters, a ceiling a JSON Schema can state,
133
+ and the act checks the bytes before the store sees them) and `meeting` to
134
+ 1 KiB of JSON. The declaration's caps are ceilings, not a budget: `page.save`
135
+ serves every page, so the ordinary page's `body` keeps the **58 KiB** it had,
136
+ and a note-only page with a large body saves as before. What is checked is
137
+ the thing itself, before anything is signed or written: the page's whole
138
+ `fields` against the store's 32 KiB **in the JSON the store writes** (escaping
139
+ a quote or a newline costs two bytes), and the whole press, at the preview and
140
+ again at the save, against **61,440 bytes** of JSON — the grant's 64 KiB less
141
+ the room ADR §4.4 keeps. Each refusal names the size and the limit and never
142
+ cuts the text. A longer transcript is later work: a Files address on the page
143
+ (`fields.transcript_file`), read in parts with the person's rights. Meeting
144
+ ids that differ only in case keep their own pages: only an id that is already
145
+ a path segment is used as it is, and anything else carries a digest of the
146
+ exact id. `review.list` rows carry `meeting
147
+ {id, path}` when a proposal came from a meeting page, and each `evidence` entry
148
+ keeps `at` (the transcript's moment, or the note's line) and `file` (the
149
+ transcript it came from) beside its quote, so a host ties an item to its
150
+ meeting and the moment it was said. The Inbox carries the same two, derived
151
+ from the proposal's own fields and read from the same space, so a Keep row can
152
+ name its meeting and its moment with nothing new stored; they are held back
153
+ behind `INBOX_ITEM_MEETING` until Jelly's strict Inbox item takes them, because
154
+ its host leaves out an item it cannot read. Proposals stay off by default
155
+ (`RECORDS_MEETING_PROPOSALS`) and the acts stay dark: this is the declared
156
+ input and answer, and the read shape (`src/ops/space-ops.js`,
157
+ `src/views/contracts.js`, `src/views/records-reads.js`).
158
+
159
+ - **Jelly's two remaining 0.11 actions, declared (#77 and #78).** `suggestion.dismiss
160
+ { id, forever? }` hides one suggestion from `mem.suggestions` without deciding
161
+ it ("Not now"), or turns its kind off in the person's own space ("Never
162
+ suggest this"); the suggestion read already carries its turn. `held.decide
163
+ { id, op: accept | edit | drop, edits? }` is one action for a held team
164
+ write's three decisions, modelled on `proposal.decide`: accept completes the
165
+ shared write, edit keeps the corrected words held, drop writes nothing. Both
166
+ are spent in the person's personal space and are bound to the version their
167
+ preview showed: a press with no live preview is refused, and nothing changes.
168
+ Both stay dark behind the plugin's `actions` and records'
169
+ `RECORDS_ACTIONS_ENABLED`, and both are **declared** now: Jelly
170
+ 0.4.0-beta.20 carries protocol major 7 and a 48-action cap, so the six acts
171
+ once held (`HELD_FOR_CAP`, `HELD_FOR_CONTROL_P2`) are declared under their own
172
+ names, making **34 actions**, with no name merged. A held write's preview shows the edited words that will
173
+ land, and the console turns a muted suggestion kind back on. See
174
+ [design/actions-0.11-suggestion-held.md](docs/design/actions-0.11-suggestion-held.md).
175
+
176
+ - **Collect wakes a resting jelly host once each morning (jelly D70/D71 and
177
+ #4262, opencode-mem#58).** Memory's `collect` routine declared no `wake`, so
178
+ on a resting host Collect waited for the host's next wake. `jelly.routines`
179
+ now declares two routines, each calling `mem.collect({})`:
180
+ `collect` every 30 minutes with `wake: false` stated explicitly, and
181
+ `collect-morning` daily at `0 6 * * *` with **`wake: true`** ("Wake once each
182
+ morning to collect new events from your enabled sources"). 06:00 is the
183
+ host's own zone: Jelly's routine schema has no `tz`, and the host writes the
184
+ agent's — the person's — IANA zone as the schedule's `when.tz`, resolving the
185
+ cron in it including daylight saving; on a cloud machine with nothing saved
186
+ that zone is UTC. **The person approves the wake once**, by accepting the
187
+ declaration on their host; they can turn either routine off in the host's routine list.
188
+
189
+ **A routine still collects with no person present.** Memory’s request guard checks
190
+ only the calls the model makes, which carry a call id. A routine’s check runs without
191
+ one, both when jelly runs a declared routine and when OpenCode runs a schedule’s check,
192
+ so `mem.collect` runs. That exemption covers `mem.collect` alone: a review decision
193
+ without a call id is always refused.
194
+
195
+ - **A proposal names its wiki, and the review read lists its sources
196
+ (`opencode-mem#63`, `#76`).** A space holds several wikis and a folder path
197
+ does not say which, so `proposal.create` takes `wiki` beside `parent` (both
198
+ already-declared fields; no new action name), and the proposal read carries
199
+ `wiki` and `parent` for the page a suggestion would create. Every
200
+ `review.list` row also carries `sources`: the evidence the proposal cites,
201
+ with its quotes, then the record's own event, turn, session or routine, each
202
+ once and at most ten — what Jelly's Review page lists as Sources. A quote is
203
+ the record's own text, so erasing the record takes it, and a ref is an id,
204
+ never a person's name. `#76` asked for `proposal.create` itself: it was already
205
+ declared (Plan A, `5225a66c`), and its input now carries `wiki`, `parent` and
206
+ `note`, so Jelly's Propose sends the wiki, the page and the note. No action
207
+ name is added, and the declaration stays at 28. That wiki is resolved in the
208
+ target space when the proposal is filed — a foreign, unknown or commitments
209
+ wiki is refused, as a copy into a wiki is — so the read never names a
210
+ destination nothing could honour. Accept does not file into the wiki yet: a
211
+ wiki holds flat files, `parent` is a records folder, and the applied page is
212
+ records' `review.decide`'s, so the row's `wiki` is the request, not the
213
+ destination (`docs/jelly.md`).
214
+
215
+ - **Memory reports its own setup time, and its tool list never moves (0.11,
216
+ jelly #80 and #81, D226).** A host starting an engine waits for every plugin's
217
+ setup, and Jelly's engine-start telemetry can name the slowest phase but not
218
+ the plugin that spent it. Memory now times its own setup, once per start, on a
219
+ monotonic clock, in seventeen named phases (`config`, `host`, `credentials`,
220
+ `backend`, `connect`, `status`, `wiring`, `tools`, `rules`, `views`, `sources`,
221
+ `skills`, `builtinSkill`, `commands`, `hooks`, `capture`, `flush`), and answers
222
+ them through the declared read `memory.setup` — `{ ms, phases: [{ name, ms }],
223
+ at }`, under `mem_status` — which reads nothing, asks for no sign-in and needs
224
+ no request, so it can be read as soon as the engine is up. `ms` is the phases'
225
+ sum (`src/setup-time.js`, `test/jelly-uptime.test.js`). Measured on one laptop
226
+ with every request stubbed (`npm run measure:setup`,
227
+ `scripts/setup-phases.mjs`): a whole setup is **5–10 ms** — 5.5 ms with the
228
+ service a Jelly account offers, 9.6 ms with an address and key of one's own,
229
+ 10.1 ms with nothing set up — and the same 7–13 ms when that address refuses
230
+ every connection, accepts and never answers, or answers control but stalls the
231
+ skill list with eight spaces. The largest phases are `flush` (3.5 ms) and
232
+ `builtinSkill` (0.6 ms); **no phase waits on the network** — the skill mirror
233
+ reads the spaces' skills after setup returns, and `skills` is now a disk read
234
+ of `stateDir/skills` (0.1–0.6 ms) — and the 25 synchronous disk reads cost
235
+ about 0.8 ms warm (`docs/jelly.md`). No behaviour changed to get there. The
236
+ registered tools are also held to being decided once, at setup: signing in,
237
+ signing out, an account change and a credential refresh leave the list
238
+ identical, inside and outside Jelly. Jelly master has no declaration field
239
+ for that yet, so none is declared.
240
+
241
+ - **Proposals from meeting pages (0.11, `opencode-mem#58` item 2).** Jelly saves
242
+ one page of type `meeting` per meeting, with its notes and links to its
243
+ recording and transcript. Memory Jobs now reads a saved meeting page — its
244
+ notes, and the transcript the page carries — and turns the **decisions and
245
+ commitments** it finds into **proposals in review, never memories**: each one
246
+ cites the page and the moment it came from (the transcript's timestamp, or the
247
+ line's offset), and nothing is stored until the person accepts, edits or
248
+ rejects it. The owner's decision of 2026-11-14 allows this to run at the
249
+ measured proposal precision (80–87%) because every proposal is reviewed;
250
+ extraction that saves a memory directly keeps the 0.90 bar, so `extract`'s
251
+ direct-save default stays `off`. **Attribution is by authorship, never by
252
+ default:** a note line is the person's only when the page is theirs and nobody
253
+ else saved it since — a guest's or a teammate's line is "someone else's", and a
254
+ page a job wrote (an external agenda) is context and proposes nothing. Each
255
+ proposal says whose line it is. Proposals are written in the space the meeting
256
+ page lives in, so a team meeting's proposals are read only by its members. The
257
+ pass is idempotent (a page whose notes, transcript and author are unchanged is
258
+ not read again, and a proposal is keyed by content), a deploy backfills
259
+ nothing (only a save marks a page; `jobs.meetings`, the owner's ask, reads the
260
+ old ones), a tick reads at most five pages, a page the budget stopped stays
261
+ pending, anything past the caps or the budget is recorded rather than dropped,
262
+ deleting the page retires its proposals, and it spends the space's one shared
263
+ day budget and respects its one breaker (counted by the service-wide cap too).
264
+ It is **off by default** under the new `RECORDS_MEETING_PROPOSALS` (unset
265
+ means off; `on` turns it on, and only after the held-out set passes)
266
+ (`records/src/jobs/meetings.js`, `records/test/jobs-meetings.test.js`).
267
+ - **A press a real Jelly makes, for the acts bound to state a preview showed
268
+ (0.11, #58 section A).** Jelly draws a confirmation from an action's preview
269
+ and presses with the same input it previewed: it never merges the preview's
270
+ answer into the press (`view-source.ts` `take`). So a page cannot send back
271
+ the fields a preview computed, and `space.manage`'s archive and leave and
272
+ `share.copy`'s version and wiki file could never be pressed from a host: every
273
+ press was refused. Memory now keeps what the preview showed — the page
274
+ version, the computed file, the membership digest — in the space store the
275
+ act is spent in (`act_previews`, through the new `acts.preview`), keyed by the
276
+ act, the canonical digest of the person's own input and the person, for ten
277
+ minutes; `acts.apply` spends that snapshot once, in the grant's transaction,
278
+ and answers it to the plugin, which puts the fields back on the operation's
279
+ input exactly as if the page had sent them. A change in between is still
280
+ `VERSION_CONFLICT`, a spent or missing snapshot asks for a fresh preview, and a
281
+ caller that does send `version` or `expectedDigest` keeps the explicit path and
282
+ its stricter check. Control's leave binds the state digest in its reservation
283
+ only when the signed input names one, so a host's press commits at the body's
284
+ digest, which control still holds to the state now.
285
+ - **Space and sharing operations for Jelly's actions (#58 A2–A9, A11).**
286
+ The service side of the actions Jelly draws, as operations and previews the
287
+ action framework registers: `page.save` (with the `meeting` page type),
288
+ `page.move` and its preview, `page.delete`, `wiki.delete` and its preview,
289
+ `space.create` (a team or a topic, invite-only or open, with members),
290
+ `share.grant` and `share.revoke` with previews, `share.transfer` as a request
291
+ the new owner accepts or declines, `page.copy` and its preview (marked with
292
+ where it came from), proposals (`proposal.create`, `accept` with edits,
293
+ `askChanges`, `reject`) and `space.join`/`space.requestJoin`. Control gains
294
+ `spaces.flavor` and `spaces.visibility` (migration 020, and a flavor is only
295
+ ever a shared space's), join requests with approve and decline, the
296
+ `joinable` read behind `mem.spaces-to-join`, and a `dry_run` share preview
297
+ that runs the commit's own checks and writes nothing; records gains
298
+ `proposals.create` and `proposals.askChanges`.
299
+ - **A handover and a join request are rows, not audit entries (migration
300
+ 021).** Each is `pending`, `accepted`, `declined`, `cancelled` or `expired`;
301
+ a partial unique index allows one pending request per target and recipient;
302
+ accepting checks `state = 'pending'` in the same transaction that moves
303
+ ownership, so a settled request cannot be resurrected, and each request
304
+ expires. A handover is G2-P: a browser session, or the host's verified grant
305
+ once P2's reservation key is set (below), and the ownership change is
306
+ recorded under the person who accepted it.
307
+ - **A proposal never rewrites a team page.** An agent may propose an added
308
+ line, never a rewrite; accepting a change to a page in a shared space is the
309
+ person's act, decided from what was written; a line-changing proposal carries
310
+ the `base_version` it was written against and a later one is
311
+ `VERSION_CONFLICT`, while an append carries no version and merges beside a
312
+ later append (its guard is that a section it found still exists, outside any
313
+ code fence; one that was not there is its own to create, as
314
+ `records.append` does); a proposal body, an added line, its section and an
315
+ `askChanges` note go through the same secret and email refusal as a direct
316
+ write.
317
+ - **A move or copy preview reads the grants, not only the members.** The new
318
+ `GET /v1/spaces/:id/readers?path=` answers who reads a path — members, a
319
+ space-wide grant, a folder grant whose prefix covers it, a page grant — and
320
+ names a group or role as that group or role. A cross-space move out of a
321
+ shared space is refused before anything is copied: the store will not delete a
322
+ team page for a bearer, so `page.copy` is the way, and the person deletes the
323
+ original in the console.
324
+ - **A space's members, and who a page is shared with, are view reads (Jelly's
325
+ ask 10).** `members.list` and `grants.list` let Jelly's space page and share
326
+ sheet read what they show instead of asking the agent: control's own member
327
+ roster and grants, behind the same `mem_spaces` permission as the `members`
328
+ and `access` actions, with control deciding every visibility rule (a viewer's
329
+ role for the roster; a page's owner or a space admin for its grants). Answers
330
+ are bounded and paged at 50 rows **and 56,000 bytes of JSON** — the limit the
331
+ other reads hold to — because a name is up to 200 characters and may be
332
+ multi-byte; a page cut for room keeps a run from the top and answers a
333
+ `cursor` for the row after its last, so nothing is lost and nothing is listed
334
+ twice. `grants.list` names one page, folder or wiki by the `resource` a `mem_share`
335
+ grant uses — the gateway's `resource_id` read, which this gives the service
336
+ client it was missing, so `mem_share` list and revoke read one page's grants
337
+ through the real gateway too — and without a target answers only the grants
338
+ that name the caller, because a key cannot list every grant in a space.
339
+ - **`mem.grants` says `scope: "mine"` when it reads the caller's own grants.**
340
+ It named that answer `space`, which no key can read: control's bearer route
341
+ answers a page's grants by `resource_id` and, without one, only the grants that
342
+ name the caller. The answer now says which it is.
343
+ - **The 17 space and sharing acts run end to end (#58 A2–A9, A11).** Each is a
344
+ declared action *and* an act records applies: a grant the host signed is
345
+ **reserved** by `acts.apply` (verified, bound to the person, spent once, with
346
+ an `act_audit` row that outlives the ledger), the plugin runs the operation
347
+ from `src/ops` **as the person whose device pressed**, and `acts.settle` makes
348
+ the receipt terminal (`applied`, or `refused` when the operation's own rule
349
+ said no). The operations keep their rules — ownership, a team page's
350
+ protections, G2-P on a transfer — and the action layer neither skips nor
351
+ repeats one. `share.revoke` is an owner device's act (`local`, always): it
352
+ takes away someone else's access, and `space.create` is always confirmed,
353
+ because a space that names members hands them access at once. A handover is
354
+ spent and audited in the space it changes, a move that copied and could not
355
+ remove the original settles `partial` with the copy's id, and an `act_audit`
356
+ row keeps every act's outcome (applied, refused, partial, unrecorded) after
357
+ its receipt is pruned. Every action's preview is a read through the same
358
+ services, with the action's own input, and writes nothing — a move, a copy, a
359
+ share, a wiki delete, a save, a page delete, a handover, a proposal decision,
360
+ a join-request decision and a visibility change — and the two older
361
+ `memory.revise.preview` and `inbox.decide.preview` read their record.
362
+ `test/actions-space.test.js` holds one end-to-end test per action and per
363
+ preview, and a refused case per action. The last two are A11's:
364
+ `space.joinRequest.decide` (approve or decline a waiting join request,
365
+ `chat`/always, previewing who gains read access) and `space.visibility` (who
366
+ can find or join, `local`/always, G2-P, previewing the members, the requests
367
+ that become direct joins, and the population). The declaration is now **34
368
+ actions and 44 RPC methods**, under Jelly's caps of 48 and 64 (protocol major
369
+ 7, Jelly 0.4.0-beta.20). The four whose control path needs P2
370
+ (`share.transfer`, `share.decide`, `space.visibility`, `space.manage`) are
371
+ declared too; without `P2_RESERVATION_KEY` each press refuses
372
+ `P2_UNAVAILABLE`, naming the secret, before control is asked.
373
+ - **P2: a verified host grant reaches a G2-P act, on in 0.11
374
+ (`docs/design/p2-control.md`).** A reservation (`src/p2-reservation.js`, four
375
+ byte-identical copies: the plugin, records, the gateway and control) is signed
376
+ by records at `acts.apply` and verified by control before a G2-P act runs, so
377
+ a grant the host signed is spent once and control's `personAtBrowser` is not
378
+ bypassed; migration 023 holds the spend. It is on where
379
+ `P2_RESERVATION_KEY` is set the same in records, the gateway and control;
380
+ with no key, the four P2 presses refuse `P2_UNAVAILABLE` in the plugin's words
381
+ before control is asked.
382
+ The gateway also serves Memory's own action key and pulls the hosts' public
383
+ keys into `ACTION_KEYS_FILE` (unset turns the puller off), refusing a file
384
+ older than its limit, and a stale key file fails closed. **A reservation is
385
+ spent only from the host it was issued to** (`p2_host`): records refuses a
386
+ grant another host signed than the request's credential names, and any grant
387
+ from a caller that names no host (`grant_host`, from the new
388
+ `x-records-identity-host` header), the gateway refuses a proof
389
+ from another host and one from a credential that names no host, and control
390
+ refuses a proof that is not the host the gateway asserted, spending it under
391
+ that host (`x-control-host`). A G2-P press is a host's press, so Memory's own
392
+ sign-in alone makes the change in the console (P1).
393
+ - **One action list behind both UIs (opencode-mem#59 §4.5).** The console now
394
+ offers every act the `jelly.actions` list declares: Browse spaces (an open
395
+ space joined, an invite-only one asked for), a handover accepted or declined,
396
+ Send a copy (A8), Suggest an edit (A9), Delete this wiki (C14, with the pages,
397
+ the readers and an honest "links from other wikis cannot be read here"), and
398
+ Edit words for a held team write before it is accepted (A15's edit half,
399
+ through a new records method `review.edit` that shares one store operation
400
+ with the `write.decide` action). Every one of those routes is a browser
401
+ session's (P1, `session_required` for a key), and each confirm is bound to
402
+ what its preview showed: a copy names the version and a page that moved is
403
+ `version_conflict`, a wiki delete carries the preview's digest
404
+ (`state_changed`), and a held write's edit names the version it edits.
405
+ `review.edit` is session-only at the gateway and again in the records store.
406
+ A copy's name comes from one function shared by the console and the action
407
+ (`shared/page-paths.js`), which also keeps the `-copy` suffix whole on a long
408
+ title. `test/console-parity.test.js` holds the two lists to each other, checks
409
+ that `pages/write` is `page.save` and `review/decide` is `proposal.decide` at
410
+ the records call they make (kind, path, title, body and type), and prints
411
+ every console act with no declared action, administration included, in full.
412
+ - **Memory as a source provider (D202, app#2346).** A top-level `sources` key in
413
+ `package.json` declares eight sources under contract version 1:
414
+ `mem.turn-receipts`, `mem.names`, `mem.members`, `mem.grants`,
415
+ `mem.spaces-to-join`, `mem.meeting-records`, `mem.suggestions` (events,
416
+ `x-mem/suggestion`) and `mem.pages-search`. They are served over the package's
417
+ tools RPC (`<package>.tools`) with `registerToolsRpc`, so a call is resolved
418
+ against the session's own rules before it runs and nothing is added to an
419
+ agent's surface. Every read runs as the session's own credential and only
420
+ reaches the spaces control lists for that person. `src/vendor/source-contract/`
421
+ carries the package's `dist/` from its PR head, dev-time only; the conformance
422
+ kit runs over every source in `test/sources-conformance.test.js`
423
+ ([docs/sources.md](docs/sources.md), #58 §B). `mem.spaces-to-join` answers
424
+ control's `GET /v1/spaces/joinable` end to end (#58 S4, A11): the
425
+ organisation's open spaces, the visibility their owners chose, marked
426
+ `join: "open"`, and never an invite-only space — a grant made by any editor,
427
+ or to a group or org role, is one person's access, not a listing — and never
428
+ a space they are in, an archived or personal one, another organisation's, or
429
+ one whose existence they may not see. Control bounds the list at 200 and
430
+ says `more`; the source keeps its own cap and passes either on, and the
431
+ console's Browse spaces shows the same list (and the cut), joining or reading
432
+ a space past the bound by id (`test/sources-spaces-e2e.test.js` runs it
433
+ against the real control and records services). Five of the sources answer their
434
+ own `x-mem/<name>` output, with its JSON Schema inline; `mem.names` and
435
+ `mem.pages-search` answer the registry's `list`. The package carries only what
436
+ the plugin imports at runtime, not the kit it is tested with.
437
+ - **A GitHub-installed plugin is found where OpenCode puts it (B6).**
438
+ `opencode plugin add github:joe-broadhead/opencode-<name>#vX.Y.Z` installs
439
+ under `<cache>/npm/git-<repo>-<sha256(target)[:12]>/<stamp>/node_modules/<name>`,
440
+ and Memory finds the stamp whose lockfile commit is the one `/api/plugin`
441
+ reports, reads its `sources` from that package on disk and hashes it. A
442
+ store that holds the plugin at another commit is refused with its own
443
+ sentence rather than the layout's. Discovery never asks npm anything: no
444
+ `npm view`, no registry fetch, and no `require.resolve` by bare package
445
+ name (a test runs it in a process where all three are traps).
446
+ - **One session, one curator (B8, reworked).** `sessions_seen` is keyed on the
447
+ OpenCode session id, in the **person's personal space** whatever space is
448
+ active, and the **first pipeline to see a session owns its curation**. Both
449
+ sides always keep their transcript: capture's `sessions.seen` records the
450
+ gateway's verified `x-records-session` (a body's `session_id` is ignored), and
451
+ History's `events.ingest` records the session its event's own `thread` names.
452
+ Curation is skipped at **read time**, counted and reversible — the natural
453
+ `listEvents` read (and so the daily routine, which also skips capture's L0
454
+ turns of a History-owned session) and the jobs' curate reader both honour the
455
+ owner. Nothing is withdrawn and nothing is written twice.
456
+ - **A page that restarts its window after the cursor advanced is a new restart
457
+ (A2).** A resync counts as the same only while the cursor is held at the
458
+ position it was counted at; the day's second real restart pauses the binding.
459
+ - **A declared account with a dash, a dot or a digit binds itself (B4).** A
460
+ per-account read's alias is everything after the plugin prefix's first dash,
461
+ so `plaud-work-2_list` names `work-2`, not `2`.
462
+ - **`needs_rebind` takes precedence (B3).** A plain pause keeps it, and only the
463
+ person's rebind clears it; resume cannot lift it.
464
+ - **Plugin text shown as markup is escaped at the display edge (B5).**
465
+ `escapeForDisplay` (`src/util.js`) is the one helper for a source's
466
+ `scope.describe`, its owner label or a note, and the contract says so.
467
+ - **A page's copy can land in a hub wiki (#57-11, A8's residual), and every page
468
+ copy now needs write access where the page is.** `share.copy` with
469
+ `op: "page"` takes `to.wiki`: the copy is written into that wiki as one flat
470
+ Markdown source file, at most 512 KiB, named from the page's own name
471
+ (`harbour-copy.md`), naming its source in the file, with the ingest started;
472
+ records writes nothing. Only a wiki the caller may write is accepted (the
473
+ space's editor, admin or owner, control's own role), a file already at that
474
+ name is refused rather than overwritten, and the preview names the wiki and
475
+ the exact file the press must send back. A copy also carries the page's
476
+ `version`: a page that changed after the preview is `VERSION_CONFLICT`, and a
477
+ press without the version is `NEEDS_APPROVAL`. The source's writer role is
478
+ required for both targets, as the console requires it, so a viewer cannot
479
+ copy a page out of their space. Class and confirmation stay `chat` /
480
+ `always`, the declared count stays 28, and `to.wiki` and `version` are inside
481
+ the grant's input digest.
482
+
483
+ - **A delivered capture can be removed by its turn's key prefix**
484
+ (`POST /v1/capture/delete`), and stays removed. The request names the
485
+ session, the visibility and the turn's full key prefix
486
+ (`<session>:<message>:`; a session-only or shorter prefix, or another
487
+ session's, is refused, so no session-wide erase is possible); the gateway
488
+ resolves exactly the placement the capture used, so the receipts are the
489
+ caller's own, and reads their message ids (never from the request). The
490
+ delete goes out with the agent and task the capture was placed with, from
491
+ the receipt, and with the turn's session (the cell matches rows on all of
492
+ them); the count is the cell's `data.deleted_count`, and a short count is a
493
+ 502 with the erase reported unconfirmed. It writes a
494
+ tombstone for the turn first, so a capture of it that arrives later is
495
+ refused (`409 capture_tombstoned`); a write still running answers `425`; a
496
+ prefix that stored nothing answers `{ deleted: 0 }`; a core that answered a
497
+ capture without ids answers `capture_delete_unsupported` rather than
498
+ pretending; and the count is the cell's own `deleted_count`. It exists for
499
+ the forget below, whose own turn another plugin instance may have delivered.
500
+
501
+ - **A person's account is erased when Jelly ID says it is deleted
502
+ (`account.deleted`, resource-token contract §10; approved by the owner on
503
+ 2026-11-14).** Jelly ID reports deletions
504
+ to the gateway (`POST /resource/accounts/events`, §10), which polls every five
505
+ minutes with Memory's own key, signing a fresh RFC 7523 assertion per request
506
+ and keeping no state; control stores each event by id (`account_events`), so a
507
+ replay inserts nothing and acting twice is harmless. On `account.deleted`
508
+ **at once** — normally within five minutes — every agent credential of the
509
+ person is revoked, every session and every grant naming them is deleted,
510
+ every membership is removed, their identity row keeps `(issuer, subject)` and
511
+ gains `tombstoned_at` (so `resolveIdentity` answers `403 account_deleted` and
512
+ nobody is provisioned again silently), their user row stays as a tombstone
513
+ (`disabled`, the email replaced by `deleted+<user id>@invalid`), and one
514
+ `account.erase.revoke` audit row records ids and counts only. **Within the
515
+ job** the same poll cycle runs a pass (a failed step retries after five
516
+ minutes, well inside 24 hours): the person's personal space is purged, its
517
+ core layers — L0 turns, L1 atoms, and L2 and L3 for every agent — are deleted
518
+ under the person's own user id, and in
519
+ each shared space they were in, copies of their private memory
520
+ (`fields.copied_from.space`), held batches, keyed-write ledgers, forgotten-copy
521
+ keys, agent grants and the source requests and proposals they made are
522
+ withdrawn while **the team's pages and their content stay**, themselves
523
+ becoming `former-member` — in the record and in every stored version. The
524
+ state machine is `queued → done` with `retrying` between passes, and a step
525
+ that succeeded is recorded in the erasure's `report`, so a retry resumes; the
526
+ gateway then purges the person from `auth.db` (the Better Auth user, sessions,
527
+ accounts, API keys, the plugin sign-in devices and grants they approved,
528
+ capture receipts, and any table a later version adds, found by the identity
529
+ columns) and confirms it. `person.erase` needs its own credential
530
+ (`RECORDS_ERASE_KEY`, sent as `x-records-erase-key` from control's
531
+ `CONTROL_RECORDS_ERASE_KEY`): a records key alone can read and write a space
532
+ and must not erase a person. A shared space nobody active remains for is
533
+ **kept and marked**, never purged, and one a grant reaches is never purged at
534
+ all — an org admin resolves it by adding an active owner, and control's health
535
+ names the ids. Two stores outlive the erasure: `deleted_accounts` (issuer,
536
+ subject, user id, event id, time; keyed by all three, kept after completion)
537
+ is the restore list, and a control restore rolls it back, which is why Jelly
538
+ ID's feed — 90 days, longer than the 37-day backup window — is the authority
539
+ after a full restore; `CONTROL_ERASED_FILE` is a second copy of erased
540
+ identities outside control's database, rebuilt at start from every erasure its
541
+ records hold and never failing open, so a restored database cannot sign a
542
+ rolled-back person in again while the feed is down. Memory-issued credentials
543
+ are held until the feed's replay drains. Erasure is off until the feed is
544
+ configured (`ACCOUNT_FEED_CONTROL_URL` and the service key), so a cell that
545
+ sets neither behaves as 0.10.x. Control's migrations are 024 (`account_erasure`),
546
+ 025 (`agent_credentials` takes the `account_deleted` reason its CHECK refused,
547
+ so an erasure of a person holding a credential no longer threw and retried for
548
+ ever) and 026 (the PostgreSQL half of 024 was keyed on `subject` alone and
549
+ failed every erasure with `42703`; the key is `(issuer, subject, user_id)` in
550
+ both dialects). Every table is classified from the schema, and the
551
+ every-table proof runs on PostgreSQL as it does on SQLite. The operator's
552
+ runbook is [docs/operations/account-erasure.md](docs/operations/account-erasure.md);
553
+ the tests are `test/account-erasure-e2e.test.js`, `-hold`, `-postgres`,
554
+ `-regressions`, `-restore` and `test/account-feed.test.js`.
555
+
556
+ - **A file removed at its source retracts what it caused (0.11).** Jelly has no
557
+ deletion channel: it re-emits the event with no words and the label `gone` or
558
+ `withheld`, so a `file` event shaped that way **is** a removal. In the page's
559
+ own transaction Memory clears the row's `title`, `text` and `url` (keeping its
560
+ labels, its moment and `removed_at`), then retracts what it derived: a waiting
561
+ proposal is retired and its quote scrubbed from the row and from every stored
562
+ version; a record the person already accepted stays theirs and loses the
563
+ removed file's citation, link and quote — in its versions too, with
564
+ `fields.removed_sources` saying which file went; a page's rendered line that
565
+ cited the event goes; and a job's staged output (`job_items`, `job_extracted`)
566
+ is deleted. A copy in another space is **reported, never retracted** (another
567
+ space's record is that space's), and the answer carries `removals[].copies`.
568
+ The person is told on that day's `journal/<date>` — the event id, the records
569
+ that came from it and the reason, never the file's name or path, which the
570
+ ingest took off the row — and only when Memory actually held the file; one
571
+ `delete_audit` row per removal records that the rule retracted something.
572
+ Finding it is indexed, not a scan: every record's citations are `cite` edges
573
+ written with the record, a space that predates them is backfilled once in
574
+ bounded slices (resumable from `meta.cite_edges`; 50,000 records in 174 ms),
575
+ and a removal that arrives while the index is incomplete **waits**
576
+ (`removals_pending`, `index_building`). The work is bounded and resumable per
577
+ event (`events.retract_pending`, `retract_after`), `sources.unbind` refuses
578
+ while a binding still has removals pending, and every `events.ingest` answer
579
+ carries `removals_pending` (a quiet tick too), as `sources.list` and
580
+ `space.stats` do per binding and per space. **The records service finishes
581
+ removals on its own clock**, not the collector's: `startRemovalWorker` ticks
582
+ about every 10 s, each tick runs slices of about 150 ms of rewrites (one per
583
+ space, ~1 s cap), the commit outside that budget, in the spaces that left a
584
+ `spaces/<id>.work` marker — never by scanning
585
+ every space file — so a deletion completes whether or not OpenCode is running
586
+ and whatever the collector's cadence is; a space being drained is skipped, and
587
+ the flag, the scrub and the resume point commit together, so nothing is done
588
+ twice and a crash loses nothing. Measured on a 10,000-record space with 500
589
+ held-file tombstones and no collector: 5 ticks, about 4.6 s of work, worst tick
590
+ 1.1 s, every quote gone in about a minute
591
+ (`docs/design/memory-v1-contracts.md`; `test/source-removals.test.js`).
592
+
593
+ - **Inside Jelly, a source read asks Jelly's broker first, and fails closed
594
+ (0.11, `feat/broker-request-identity`).** A declared source's read goes through
595
+ the contract's `sourceReader`: Jelly's host broker first (`jelly.core.request`,
596
+ kind `broker`), then the embedded tools-RPC read. The request is the package's
597
+ own `brokerRequest`, carrying `package`, `version`, `descriptorHash` and
598
+ `consumer: "memory"` — and the hash is the consent's **confirmed** digest, not
599
+ merely the installed one, so Jelly enforces what the person confirmed.
600
+ **It fails closed:** an unreachable core plugin, a rejected call, an empty or
601
+ malformed answer all become `{offered: true, ok: false, UNAVAILABLE}` and hold
602
+ the binding, and **only Jelly's own explicit `{ offered: false }` lets a read
603
+ run embedded**, so a broker that is off or unwell is never a way around
604
+ Jelly's declaration and grant checks. It is offered only inside Jelly: an RPC
605
+ id has no owner, so nothing asks one outside it. A read has a **30 s budget**
606
+ (`SOURCE_READ_TIMEOUT_MS`) and the broker the same 30 s
607
+ (`BROKER_TIMEOUT_MS` = `SOURCE_READ_TIMEOUT_MS`), the abort
608
+ passed in OpenCode's own shape so a parked request is really removed, one
609
+ broker deadline per tick, and — once a plugin's call times out — a **per-plugin
610
+ hold for the rest of that tick**, so a silent broker pauses one binding and
611
+ never stalls collection. **A changed declaration pauses; it does not read.**
612
+ Any `PERMISSION_DENIED` on a bound source pauses as `DECLARATION_CHANGED` /
613
+ `needs_rebind` when the installed digest differs from the confirmed one, and as
614
+ its own `ACCESS_REFUSED` ("Memory's access to this source was refused …") when
615
+ they are equal, so a withdrawn grant cannot loop; the refusal's own code is
616
+ recorded, never its English message. `plugins.reconfirm` is a real "Confirm
617
+ again": a browser-session write at the gateway, it previews the declaration
618
+ installed now (digest, scope keys, scope), records exactly the digest the
619
+ dialog showed, and clears only a declaration change — an owner or account
620
+ change stays paused as `rebind_required` — so **reconfirm and resume work per
621
+ binding**, and `plugins.resume` names one (`source` and `account`), leaving the
622
+ plugin's other bindings as they were. **The contract's source-id grammar is
623
+ accepted** for declared sources (`slack.workspace`, `gws.calendar.today`, at
624
+ most 64 characters) beside Memory's word rule, in one module
625
+ (`src/source-ids.js`) whose copies the records service and the console carry
626
+ byte-identically, so such a source can be requested, consented and
627
+ reconfirmed (`test/source-ids.test.js`). **Jelly's broker is OFF until
628
+ source-contract #8 settles** — it is off unless `JELLY_SOURCE_BROKER=on` — so
629
+ **reads stay embedded today** and production behaviour is unchanged; the gate
630
+ runs with it off.
631
+
632
+ - **Jelly's own sheet, its reads and its tiles (0.11, Jelly's #55 and #72–#75;
633
+ `feat/jelly-declarations`).**
634
+ - **The read-only twins.** `mem.pages` (list, read, links, history) and
635
+ `mem.wikis` (list, search, read, status) carry exactly today's reads and
636
+ write nothing anywhere, are declared `readOnly`, and are **registered only
637
+ inside Jelly**. Jelly's fence keeps the tools a declaration marks `readOnly`
638
+ and drops every other one, and `mem.page` and `mem.wiki` each hold reads and
639
+ writes together — so a researcher or a reviewer Jelly fences to read-only
640
+ tools was given neither, no page and no wiki, ever. Each twin runs the same
641
+ code as its write tool and refuses a write action whatever a caller sends, so
642
+ every write stays in `mem.page`/`mem.wiki` behind its `page.write`,
643
+ `page.delete`, `wiki.write` or `wiki.delete` ask. Each is described in one
644
+ sentence of its own, is labelled in the "Searching memory" work kind, and is
645
+ **not** in the generated agent protocol, the namespace line or a skill — so
646
+ **OpenCode's tools and the protocol are unchanged**; only a Jelly host's
647
+ fenced agent ever sees them. They cost 1,375 direct-tool characters (Jelly's
648
+ 28,848 against OpenCode's 27,473), inside the **1,400** the owner allowed for
649
+ the twins: a ceiling of their own, added to OpenCode's unchanged
650
+ `directTools` budget, with nothing else allowed to grow into it
651
+ (`test/surface-budget.test.js`).
652
+ - **The `ownService` switch, applied exactly as Jelly's sheet shows it.** Off —
653
+ including unset, whose declared default is `false` — is the service the
654
+ person's Jelly account offers, and inside Jelly **nothing of their own is
655
+ read**: no address, no key, no explicit core or knowledge URL, so a key of
656
+ theirs can never reach another operator's server. On with an address uses it;
657
+ on with no address loads and answers `connected: false`, `state: "unconfigured"`
658
+ naming the field, instead of throwing. **An address saved
659
+ before 0.11 is not used while the sheet shows the switch off, and the person
660
+ is told so** rather than switched servers silently (Jelly's pause for a
661
+ legacy address). Outside Jelly an address set still means one, so every
662
+ install before 0.11 keeps working. `controlURL` and `token` are
663
+ `visibleWhen` the switch — display only, as Jelly's contract says.
664
+ - **The sign-in row.** One `account` row ("Memory account") over the `memory`
665
+ integration the plugin already registers, `required: false` because a pasted
666
+ key alone is enough, and `presetBy: "token"`, so the sheet shows one row or
667
+ the other and never both, and Sign out is the engine's on that integration.
668
+ It is registered whenever Memory has an origin and left unmatched
669
+ ("Optional", no method) where Jelly's identity signs the person in and the
670
+ credential would be ignored.
671
+ - **One tile sentence per state**, and the switch's own two states answer
672
+ before anything asks a credential: `unconfigured` naming the field, `paused`
673
+ in one 57-character sentence naming the switch the person must turn on, and
674
+ the overview carries **no simulator address** (`http://127.0.0.1:8420` was
675
+ the base URL's default, not a service anyone typed).
676
+ - **Preview titles.** The answer all four previews share — `review.decide`,
677
+ `write.decide`, `proposal.decide` and `inbox.decide` — carries `title`: the
678
+ record's own title, else the first line of its words, on one line, at most
679
+ 120 characters. Jelly's panel can then read `Keep "<title>"?` instead of a
680
+ raw `rec_…` id, and the field is declared with a sample on each
681
+ (`test/jelly-held-title.test.js`).
682
+ - **Space counts, for members.** Each `spaces.list` row, and the `space` of
683
+ every read that names one, carries `members` (how many people it is shared
684
+ with) and `wikis` (how many wikis it holds), answered by control from its own
685
+ tables in the same query that lists the spaces a person can see, so the
686
+ Spaces page draws its per-row counts; a count is never a list of people or
687
+ grants, a **member** sees every wiki in the space (a space role reaches every
688
+ resource, collections included) and a grant-only viewer gets no counts, and
689
+ either field is left out when the answer has none rather than invented as
690
+ zero. Work kinds gain `revise`, `page` and `commitments` of their own, so a
691
+ conversation says what Memory did and every declared tool is still labelled
692
+ once.
693
+
694
+ ### Changed
695
+
696
+ - **OpenCode's range gains a ceiling: 2.1.4 or newer, below 2.4.0, and a host outside it is told
697
+ why.** 2.3 is tested (jelly moves its engine to 2.3) and nothing above it is. `setup` refuses a
698
+ newer host, and the floor refuses an older one, by registering **one tool, `mem_off`, and nothing
699
+ else** — no hooks, no protocol block, no request — whose description and answer say the reason in
700
+ full ("Memory is off: this OpenCode (2.4.0) is newer than Memory supports. Update Memory, or use
701
+ OpenCode below 2.4.0."), and by writing the same sentence to Memory's own debug log at `ERROR`.
702
+ **OpenCode discards a plugin's `console.error`**, so a message there would have left a person with
703
+ memory tools that vanished and no reason; the tool lets the agent tell them, and the log is the
704
+ second place to look. `docs/troubleshooting.md` names both, then OpenCode's own log (where a
705
+ registration failure lands, because that throw is not caught). `versionBelow` is the mirror of
706
+ `versionAtLeast` (`src/util.js`), and both drop a leading `v`, so `v2.3.0` is admitted rather than
707
+ refused as older than 2.1.4. The floor is unchanged, and `versionAtLeast("3.0.0", 2, 1, 4)` is
708
+ still true, so the ceiling is the only new refusal. `test/version.test.js` pins 2.3.0 and 2.3.9 in,
709
+ 2.4.0/2.5.1/3.0.0 out, the floor's own five cases, `v2.3.0` in and `v2.4.0` out, and — for both
710
+ refusals — exactly one tool whose description and answer carry the sentence, no skill, command, RPC,
711
+ namespace or hook, no request, and the sentence in the debug log.
712
+ What 2.3 changed for a plugin, and why it does not touch Memory: **`ToolContext.cancel` is removed**
713
+ (Memory never read it) and **`signal` is now a cooperative stop** — reading it, or spreading the
714
+ context, opts in, and no Memory tool does either, so Memory's tools stay in the interrupted class
715
+ with a stopped call reported as on 2.2.6; **background subagents** keep the child's `parentID` and
716
+ add no `session.*` event type, and capture keeps a tool's name and never its output, so neither the
717
+ session tree nor a captured turn changes. Measured on an isolated 2.3.0 and 2.2.6 binary (own
718
+ prefix, own XDG roots, `--standalone`): Memory loads in both, the host holds the same 36 tools with
719
+ the same 16 `mem_*` names, `core` passes 38/38 on both, and `tools` 15/15 on 2.3.0 against 14/15 on
720
+ 2.2.6 — that one item (`tool-share-revoke`) trips its own "at most 4 memory calls" budget on both
721
+ engines in a re-run (1/3 each), so it is the item's instability, not 2.3. **A new `opencode-real`
722
+ CI job** runs a real 2.2.6 and 2.3.0 binary through start, load, tool list and one Code Mode tool
723
+ call (`scripts/opencode-smoke.mjs`, a local fake provider, no credential).
724
+
725
+ - **Memory no longer detects its host.** Jelly-only surfaces are gated on what the host offers through the contracts, never on whether the host is jelly.
726
+ - **The read-only twins (`mem.pages`, `mem.wikis`), `ownService` and its key handling follow the resource-token contract:** they apply only where the host offers Memory a `memory` resource.
727
+ - **The host's identity token goes only to the origin its `memory` resource names,** decided per request. So it never reaches a person's own Memory address, even when the host offers the resource after start.
728
+ - **Source reads ask the host's broker only where the host offers the `memory` resource.** There, only an explicit `{ offered: false }` reads embedded, and every other broker failure holds the read. **In plain OpenCode, sources are always read embedded.**
729
+ - **A new `plain-opencode` CI job runs Memory in a host shaped like OpenCode's** (a callable `rpc`, no `memory` resource), and fails if a jelly-only surface appears.
730
+
731
+ - **The console-only gaps become declared actions (Plan A, #59 §4.5).** One
732
+ name per console act, in the safe shape §3.1 of the action-cap proposal
733
+ decided: `page.move` gains `prefix` (a whole folder, `records.move`'s own
734
+ `path_prefix` branch) and `paths` (up to fifty pages) and `page.delete` gains
735
+ `paths`; `memory.revise` gains `add`; the new `memory.organise` (`op: move |
736
+ retire | restore | confirm`, with a preview that names the op) absorbs the
737
+ console's `memories/bulk` and `memories/move`; the new `share.copy`
738
+ (`op: page | memories`) absorbs `page.copy`; `space.join` gains `op: join |
739
+ request` and absorbs `space.requestJoin`; and `commitment.create`,
740
+ `commitment.delete` and `commitment.move` close the console's commitments
741
+ area. Held back with the other control-P2 acts: `share.decide`
742
+ (`op: accept | decline`) replaces `share.accept` and `share.decline`, and the
743
+ new `space.manage` (`op: rename | archive | unarchive | leave`, `local` /
744
+ `always`: leaving cannot be undone) closes the space lifecycle. Each grouped action's `op` is bound to the change it makes:
745
+ the gateway checks the signed op before forwarding and control checks it again
746
+ and spends the reservation as that one act (for `space.manage`: its op, its
747
+ space and its change), so a press signed to decline can never accept, or one
748
+ space's rename rename another. A leave or an archive carries the preview's
749
+ digest **in the signed input**: the plugin refuses a press without one rather
750
+ than filling it in. The declaration carries 34 actions of Jelly's 48, every
751
+ act wired and named once; a deployment without `P2_RESERVATION_KEY` refuses a
752
+ P2 press `P2_UNAVAILABLE`. A grant still binds one action and one input digest, so a
753
+ grant for one `op` cannot authorise another (`test/actions-space.test.js`).
754
+ - **Five console acts stay console-only, each with its reason in the parity test.**
755
+ `memories/lift` (records' `forgotten.lift` refuses every bearer, so it needs a
756
+ grant door of its own), `memories/move` (a move changes who can see a memory,
757
+ so it needs its own action; this release does not add it) and
758
+ `spaces/request-deletion` (P1 by design: control refuses a host
759
+ grant for a deletion request). `learned/correct` and
760
+ `learned/forget` stay console-only too: they change atoms in the memory core,
761
+ which has no grant door, so records' `memory.revise` and `memory.forget`
762
+ cannot reach them.
763
+ - **No name Jelly's app binds was renamed.** `commitment.done|cancel|reopen|
764
+ snooze|edit`, `page.write`, `page.save`, `profile.erase` and `space.create`
765
+ are declared exactly as `detect.ts` looks for them. The four names this
766
+ change removes — `page.copy`, `space.requestJoin`, `share.accept`,
767
+ `share.decline` — appear in Jelly master only in its asks document, never in
768
+ its app code.
769
+ - **The gateway's and control's P2 act lists follow the declaration.** Both name
770
+ `share.decide` (not `share.accept` and `share.decline`) and `space.manage`, and
771
+ each act's `op` is checked against the route or the change it makes.
772
+ - **Jelly's cap is checked on the whole wired set.** `test/actions.test.js` holds
773
+ `ACTION_NAMES` (declared plus held) to 32 as well as the declared set, because
774
+ a declaration over the cap is refused whole.
775
+ - **The job tick opens only the spaces that have work (0.11).** It used to open
776
+ every space every minute to read its job rows, which turns over the store's
777
+ open-file cache (128 handles) once a cell holds more than 128 spaces. It now
778
+ keeps one small index per space — its earliest due job (one that already has
779
+ a queued or running run is not work), when its earliest `running` row would
780
+ go stale, and how many finished runs wait for curate — recomputed by every
781
+ job write in the same transaction and rebuilt by one scan at start, so a
782
+ restart still finds the stale `running` rows §4.2 re-queues. A space the
783
+ index has never seen — installed after the scan, or written while it ran — is
784
+ read once on the next tick, so a new space is never invisible; a space whose
785
+ file is gone drops out as the tick lists the files. Tests: 500 spaces, 3 with
786
+ a due job, open exactly those 3; a space installed with a due job after the
787
+ scan and a job written during it are both ticked on the next (same) pass.
788
+ - **One model budget and one breaker per space, for the routines and the job
789
+ runner together (0.11).** `RECORDS_BUDGET_TOKENS` was the routines' day and
790
+ each job had its own caps; the day is now the sum of both ledgers (the
791
+ routines' `runs` and the jobs' `job_runs`, store method `modelTokens`), and
792
+ one breaker per space stops both sides' calls
793
+ (`records/src/model-guard.js`, created once by the service and passed to
794
+ both). **The day is the space's own local day** — its local midnight to the
795
+ next one in UTC (`dates.js` `dayBounds`), the space's `fields.tz` — so an
796
+ evening run in New York is that day's and never the next UTC day's, and a run
797
+ just after local midnight east of UTC stays in its day. `routines.status`
798
+ shows the shared `breaker` beside the day's `budget`
799
+ `{limit, day, used, routines, jobs}`; a new
800
+ `RECORDS_LLM_BREAKER_COOLDOWN_MINUTES` (`60`) sets the cool-down, and
801
+ `RECORDS_LLM_BREAKER_FAILURES` keeps its documented `5`. A space under budget
802
+ runs exactly as before. `RECORDS_JOBS_EXTRACT` is still off by default: the
803
+ shared budget is a prerequisite for turning it on, not a decision to.
804
+
805
+ - **A start no longer waits for Memory's server to say who is signed in
806
+ (opencode-mem#58).** `/connect` keeps a Memory sign-in in OpenCode's own
807
+ store, and renewing it is a request; setup used to await that probe, so with a
808
+ sign-in due for renewal every engine start waited on Memory's server — about
809
+ 15 s against a server that never answered, where a signed-out start takes a
810
+ few milliseconds. Setup now reads only what the host holds on disk (no
811
+ request, bounded at 250 ms), starts the probe in the background and awaits
812
+ none of it; the renewal and the answer are bounded (10 s), a failure is
813
+ logged once instead of vanishing, and a tool call made before the probe ends
814
+ joins it and answers from it. **A person sees nothing change except the
815
+ wait:** the tool list and every tool's words are the same, and the start's
816
+ own line and warnings now name the sign-in on disk, which the probe corrects
817
+ (a sign-in for another Memory address, or an ended one, is reported by the
818
+ first use and in the log). **Nothing a person wrote is sent without an
819
+ identity:** the spool's replay and the backend probe start only once the
820
+ probe confirms the sign-in, and a gateway request with no credential at all
821
+ is refused before it is sent rather than sent bare (local direct mode, which
822
+ has no gateway address, still sends without one). Tests:
823
+ `SU-setup-does-not-wait-on-server`,
824
+ `SU-first-use-waits-for-probe`, `SU-background-failure-is-quiet`,
825
+ `SU-signin-for-another-address-not-claimed`, `SU-fresh-start-keeps-its-skills`,
826
+ `SU-unconfirmed-signin-sends-no-spool`, `SU-unusable-signin-sends-no-spool`,
827
+ `SU-confirmed-signin-flushes`, `SU-no-credential-sends-nothing`.
828
+
829
+ ### Fixed
830
+
831
+ - **The agent no longer collects or decides proposals unasked.** `mem_collect` and a review decision the model makes run only when the person's latest message asks for them; a host's routine still collects. Recall's line about collected mail now offers a collection instead of inviting one.
832
+
833
+ - **Plugin sources reach Memory under the account they really read.**
834
+ - **The bug:** a source whose plugin reads one account of its own (History, Linear, X) answers its probe and its pages with that account. Memory insisted on `default`, and refused them (`ACCOUNT_MISMATCH`).
835
+ - **A binding for such a source is now keyed by the account its probe reports.**
836
+ - **Binding it again for a different account supersedes the old binding,** which stops collecting and keeps what it collected.
837
+ - **Snapshot sources are not offered in this release.** `slack.dms`, `gws.calendar.today` and `gws.image` are `snapshot` sources, which 0.11 does not collect. The console and the tool now say so, instead of offering a binding that collects nothing, and a snapshot binding made earlier is marked as not collected.
838
+ - **The Sources row shows the installed plugin's version beside the release that declares its sources,** and says when a binding is catching up (a run ended with more to read). **Nothing is refused on a version:** a git-pinned or `0.0.0` build keeps collecting through the earlier path.
839
+
840
+ - **A source can no longer be bound twice under two names.**
841
+ - **The bug:** once the family plugins declared their sources under source-contract, a source's legacy alias (`gmail`, `slack`, `x`, …) stayed bindable beside its declared names (`gws.gmail`, `slack.workspace`, `x.*`), so one account could be collected twice.
842
+ - **One rule in records now decides what can be bound,** and every path uses it: the console, the agent's tool, and plugin consent. Once a package declares its sources, its legacy alias is no longer offered, and it's refused for an account already bound under a declared name, and the other way round.
843
+ - **Existing legacy bindings keep collecting, once.**
844
+ - **Sibling declared sources bind together** (`x.mentions`, `x.bookmarks`, `x.timeline`).
845
+ - **`slack.mentions` is not mapped:** its overlap with `slack.workspace` comes from Slack's own two sources.
846
+
847
+ - **A source is not offered twice under two names, and a second binding of the
848
+ same account is refused (audit 1.3; review F1, F2).** The nine family plugins
849
+ now declare their sources, so `gmail` and `gws.gmail` were both bindable for
850
+ one mailbox and Memory curated it twice; X's legacy `x` was not mapped at all,
851
+ so `x` beside any of `x.mentions`, `x.bookmarks` and `x.timeline` read — and
852
+ paid for — the same feeds twice. One rule now lives at the records service
853
+ (`records/src/plugins/legacy-sources.js`), where every path converges: a
854
+ legacy alias whose package declares is not offered and not bindable, and a
855
+ second name for an account already bound or requested is refused with a next
856
+ step that names the declared source and the trade (unbinding deletes the
857
+ existing events). `sources.request`, `sources.bind`, `plugins.request` and
858
+ `plugins.consent` run it; `plugins.list` answers the retired aliases with the
859
+ declared sources each stands for, so the console stops offering them and
860
+ explains a refusal in those words (its other records refusals keep their fixed
861
+ message); the plugin's `mem_spaces` keeps no copy of the rule and shows the
862
+ server's answer. A declared source is the same account as its alias alone:
863
+ X's `x.mentions`, `x.bookmarks` and `x.timeline` are three feeds, so all three
864
+ bind beside each other for one account (round 2 fixed them refusing each
865
+ other). `slack` maps to `slack.workspace` only — `slack.mentions` is another
866
+ tool and API the legacy name never called, and the overlap between Slack's two
867
+ declared sources is Slack's to solve, not this alias map's. A binding made
868
+ through an alias before its package declared keeps collecting exactly once,
869
+ with its events, and a legacy request filed before the declaration cannot be
870
+ confirmed into a new one after it. Tests:
871
+ `SC-console-no-retired-alias`, `SC-console-no-double-bind`,
872
+ `SC-records-consent-no-double-bind`, `SC-declared-siblings-bind`,
873
+ `SC-legacy-vs-declared-both-orders`, `SC-x-mapped-no-double-read`,
874
+ `SC-nine-families` (each of the nine, from its released declaration, and its
875
+ sibling sources), `SC-alias-retired-when-declared`,
876
+ `SC-no-double-bind-same-account`, `SC-legacy-binding-still-collects`.
877
+
878
+ - **The Inbox read keeps within Jelly's answer limit.** Jelly ignores a plugin answer over 65,536 bytes and silently keeps the person's last Inbox (`backend/host/src/plugin-views/rpc.ts:247`). `inbox.list` now fits its answer within 61,440 bytes. It drops evidence quotes first, then meeting links, then shortens item text, the last item first. It never drops an item or changes a key. Today's reads peak at 28–33 KB and are unchanged: this guards the meeting fields, which stay off (`INBOX_ITEM_MEETING`).
879
+
880
+ - **The daily routine's own copy of a model error reached the journal page and
881
+ the log (0.11 review, round 3, follow-up).** `daily.js` kept `llmError` raw, and
882
+ two readers took it: the journal page ("The model failed on part of the day
883
+ (…)") and the `memory.routine.llm` log line. The store's secret gate withholds
884
+ a *named* secret but not one in a URL query, so a provider error quoting an
885
+ Azure SAS URL stored the whole signature in a page that is full-text indexed
886
+ and shown by the console, and the log held the raw `sk-proj-…` key and the
887
+ Bearer token. `llmError` now goes through the shared redactor at that one site,
888
+ which drops the query and keeps the host and the HTTP status, so the page and
889
+ the log both stay diagnosable. The routine's other failure logs (the ledger, a
890
+ tick stage, a write) take the same redaction. Journals written before this fix
891
+ are **not** rewritten: an ordinary page's body is the person's own text, and
892
+ redacting every page on read would drop a URL's query from content that is not
893
+ a failure. Such a page holds the line under the fixed prefix "The model failed
894
+ on part of the day (", so a one-off script can find and redact that line, and
895
+ the person can edit the page. Test: `RS-daily-llm-error-redacted` (the log and
896
+ the page).
897
+ - **A model provider's error reaches no store or surface with its secret
898
+ (0.11 review, round 3).** `routines/src/llm.js` carries the provider's own
899
+ words (`the model answered 500: …`), and a provider's error can quote a key or
900
+ a URL with a token. A daily run kept that text in its ledger row
901
+ (`runs.run.error`, and again in its `result`), and `listRuns`,
902
+ `routines.status` and `space.stats` `last_runs` returned it — so the console's
903
+ Home, Spaces and Activity and `mem_spaces` health showed it. The routine's
904
+ error is now redacted with the shared `storable.js` redactor where the run is
905
+ finished (so its log line and its answer are too), and the records service
906
+ redacts `run.error` and `result.error` on write (`putRun`) and on read
907
+ (`listRuns`, `space.stats`), so a row an older build wrote cannot show one
908
+ either. A job's model-stage errors and the model breaker's log line take the
909
+ same redaction. Test: `RS-routine-llm-error-redacted` (the stored row,
910
+ `listRuns`, `routines.status` and `space.stats`).
911
+ - **An old source row shows no secret on Sources or Home (0.11 review, round 2).**
912
+ The two columns a **0.9.x** database holds were written long before 0.10.4's
913
+ gate: `source_requests.note` (the plugin's own sentence about a failed probe)
914
+ and `source_collections.error` (the collector's last failure). `sources.list`
915
+ returns both and the console shows them, so an old row still displayed a
916
+ `Bearer sk-live-…` and a `token=tk_…` verbatim. Both are now redacted where
917
+ they are **read**, with the redactor both packages carry (`errorText`), so a
918
+ row written before the fix cannot show a secret through any reader and a row
919
+ this build wrote is answered unchanged. They are redacted on write too
920
+ (`sources.report`, `sources.collected`), as are a host's `jobs.finish` error
921
+ **before** its 300-character slice, a job probe's `note` (`jobs.probe` and
922
+ `jobs.request`), and `plugins.pause`/`plugins.flag`'s caller-supplied reason
923
+ and the `plugin_paused` conflict, which quote a stored consent reason. Test:
924
+ `RS-old-source-rows-redacted-on-read` (raw 0.9.x rows planted, then read).
925
+ - **A job stores and shows no secret from a source's page, and the status file
926
+ redacts `held` too (0.11 review B1 and S1).** The other way a source's page
927
+ reaches the store is a **job**, and jobs are on by default: `jobs.checkpoint`
928
+ forwarded the page's `refused[]` and `failed[]` text, the records service kept
929
+ it in `job_runs.refusals` and `job_logs.detail`, and `mem_spaces` `logs` and
930
+ the console Jobs page showed it — a `Bearer sk-live-…` and a `token=tk_…`
931
+ verbatim, because slicing to 100 characters protects nothing. The redactor now
932
+ lives in `storable.js`, which both the plugin and the records service carry, so
933
+ records redacts each `refused[].reason` and `failed[].reason` **before** the
934
+ slice, and redacts them again as it answers `jobs.runs`, `jobs.logs` and
935
+ `jobs.list`, `plugin_consents.reason` and `plugin_requests.note` — so a row a
936
+ build before this fix wrote cannot show one either, through any reader
937
+ including the console. `collector.json` redacts `held` field by field, as the
938
+ rest of the row already was. Tests: `RS-job-checkpoint-redacted` (the answer,
939
+ the two rows, the answers records gives, and the `mem_spaces` line over a raw
940
+ pre-fix row) and `RS-status-held-redacted`.
941
+ - **A source's own failure text is redacted wherever it is stored, logged or
942
+ shown (0.11 review F1 and F2).** 0.10.4's `errorMessage` and `redactErrorText`
943
+ gate every failure the answers carry, and 0.11's source paths bypassed it: a
944
+ pausing `AUTH_REQUIRED` sent its raw message to `plugins.pause`, and the
945
+ records service kept it in `plugin_consents.reason`, which every process and
946
+ the console read — a probe stored `refresh_token=…`, `token=tk_…` and
947
+ `Bearer sk-live-…` verbatim. The pause reason, a refusal's reason, the
948
+ sentence a source says about its own setup, a bind request's note and a
949
+ skipped run's reason are now redacted where they are written, and
950
+ `collector.json` — the status file every process reads — is redacted field by
951
+ field as it is written, so a status file from an older build cannot leak one
952
+ either. Tests: `RS-pause-reason-redacted`, `RS-refusal-reason-redacted`,
953
+ `RS-status-file-redacted`.
954
+ - **A bind's clear refusal reaches the person on a real host, not "try again
955
+ later" (`opencode-mem#69`, contract v0.1.0 review F5).** Real OpenCode answers
956
+ an RPC method a plugin registered no handler for with its own type,
957
+ `rpc.method_not_found` (`@opencode/core` `rpc` `call`), thrown to the plugin as
958
+ the engine's plain `{type, message}`; a handler that fails is `rpc.internal`,
959
+ "RPC call failed". The first is now mapped to the contract's refusal — the
960
+ source implements no probe method, nothing was read, and declaring
961
+ `sources.probe.action` is optional — and every other failure is left exactly as
962
+ it is. Test: `F5-real-opencode-missing-method-refused`.
963
+ - **A declared source that declares no probe is refused, in its own words
964
+ (`opencode-mem#69`, contract v0.1.0 review F5).** A bind reads the person
965
+ through the contract's `probe`, and the contract refuses
966
+ `events_list({ limit: 0 })` for a declared source, so a descriptor with no
967
+ `sources.probe.action` had nothing to fall back to: the request failed with
968
+ "the host has no RPC method …/probe", which names the wrong thing, and the
969
+ path was untested. `probeSource` now refuses before any host call, with
970
+ `SCHEMA_VIOLATION` and the declaration that is missing, and the collector
971
+ reports those words to the person; the previous contract's owner-only page is
972
+ never used for a declared source. Test: `F5-no-probe-refused`.
973
+ - **A space past control's 200-row bound is readable through Memory
974
+ (`opencode-mem#67`).** `GET /v1/spaces/joinable` cut at 200 open spaces and
975
+ said `more`, and dropped the `space=` query control takes to look one row up by
976
+ id: the 201st was offered to nobody, so a host that showed the cut could not
977
+ reach what it said was left. The route passes `space` on, and a test reads the
978
+ 201st by id beside a cut page that says `more`. Browse spaces stays the
979
+ declared source `mem.spaces-to-join` — one declaration, with its own
980
+ `outputSchema`, `probe` and `more`, rather than a second view read of the same
981
+ rows (`docs/sources.md`).
982
+ - **`members.list` and `grants.list` keep their whole answer inside the view
983
+ limit, its cursor included (`opencode-mem#65`).** The page was fitted to
984
+ `ANSWER_BYTES` on its rows alone, then the read added `more`, a cursor bound to
985
+ the space and target ids, and the "mine" note: a 200-character space and target
986
+ put fifty hostile rows at 56,233 bytes, over the read's own limit (the 64 KB
987
+ view cap still held, with the 8 KB margin). The fit now keeps
988
+ `ACCESS_TAIL_BYTES` (1,024) for those fields before it keeps a row, so what the
989
+ host reads is inside the limit, and a test fits a hostile page through both
990
+ reads. The `mine` assertion that passed on an empty list now names the grant the
991
+ caller holds and nothing else in the space.
992
+
993
+ - **A start no longer waits for the skill mirror (0.11, jelly #80 F1).** Setup
994
+ awaited the refresh of the spaces' skills, so a slow or missing Memory server
995
+ was charged to the engine's start: 2,010 ms against a server that accepts and
996
+ never answers, 4,192 ms when it answered control but stalled the skill list,
997
+ and 33,301 ms with eight spaces (each space's list one after another, each
998
+ with a retry). The mirror on disk is now the start's source: a refresh writes
999
+ `stateDir/skills/<id>/SKILL.md` with a `skill.json` beside it, and setup
1000
+ registers those files before anything asks the network
1001
+ (`registerMirroredSkills`, `src/skills.js`), so the first session of a start
1002
+ has its skills with the server down. The refresh runs after the start, under
1003
+ one 1.5 s deadline, reading every space's list in parallel with no retry, and
1004
+ swaps the registration when it completes; a skill published since the last run
1005
+ arrives at the session bind, which already refreshes the space it binds. A
1006
+ fresh host with no mirror behaves exactly as before. Measured with
1007
+ `npm run measure:setup` (the harness now gives its stub real spaces and
1008
+ contexts, and drives blackhole, refusal and stalled servers): the same three
1009
+ cases are 12.8 ms, 8.5 ms and 6.6 ms, inside the 5–10 ms a start takes with
1010
+ everything answering. `JU-setup-never-waits-on-skills` and
1011
+ `JU-cached-skills-at-first-session` hold it.
1012
+
1013
+ The cache is bound to its owner: `skill.json` records the server origin and a
1014
+ hash of the account subject it was mirrored for, and setup registers a cached
1015
+ skill only when the sign-in names that same account and origin (asked of
1016
+ Jelly's own accessor, bounded, never a request). Signed out, signed in as
1017
+ someone else, or on another server, none of the cached skills is registered —
1018
+ the previous account's private skills never come back — and the refresh fills
1019
+ them instead. The background refresh has a 10 s deadline, enough for a slow
1020
+ server (three round trips at 600 ms are 1.8 s), and a host with nothing usable
1021
+ cached retries it with backoff (5 s, 30 s, then every 2 minutes) until it
1022
+ succeeds, so a fresh host on a slow server still gets its skills and a dead
1023
+ one costs occasional requests. A personal-space session bind refreshes the
1024
+ mirror too, not only a shared one, and every timer is cleared on dispose.
1025
+ `JU-cache-not-used-after-sign-out`, `JU-cache-not-used-for-another-account`
1026
+ and `JU-fresh-host-gets-skills-at-600ms` hold it.
1027
+
1028
+ - **A forget no longer leaves its text in the turn that asked for it** (the
1029
+ 0.9.14 gate's `tool-revise-forget#2`). The person asked Memory to forget a
1030
+ Wi-Fi hint; the forget worked, and the agent's answer in the same turn quoted
1031
+ the hint, so the turn's capture stored it and the text survived in Memory's
1032
+ own L0 transcript. Exact-text masking cannot close this — a paraphrase of the
1033
+ forgotten text carries no run of its words — so the turn is not kept at all:
1034
+ when a forget succeeds, the session is marked while its turn is open
1035
+ (`src/forget-turn.js`), that turn is not captured, and one log line keeps its
1036
+ place, naming the session and never the text.
1037
+ - **A subagent's forget marks the parent's and the root's turn too**: without
1038
+ `captureSubagents` the child has no turn of its own, and the parent's turn
1039
+ is the one that carries the request and the task's result. The tool result
1040
+ always tells the agent not to repeat the forgotten text.
1041
+ - **Every plugin instance sees the drop.** The instance that runs the forget
1042
+ takes the turn's capture claim while the turn is open, so another instance
1043
+ over the same event stream finds it at its flush.
1044
+ - **Only a turn the forget can be tied to is touched.** A finished turn is
1045
+ never deleted or dropped, whatever it holds. A foreground subagent's
1046
+ parent turn (the one open when the host created the child) is dropped with
1047
+ the child's own; a background child never marks a later, unrelated parent
1048
+ turn.
1049
+ - **A steered turn is offered, not deleted.** A turn flushed because the
1050
+ person steered, or evicted mid-flight, may hold the text and stays; the
1051
+ forget's result says so and asks the agent to offer removing it, with the
1052
+ person's consent.
1053
+ - **A copy of the forget's own turn is erased even if another instance
1054
+ delivered it first.** The plugin awaits `POST /v1/capture/delete`, which
1055
+ tombstones the turn (one receipt lifetime) and deletes its message ids
1056
+ under the capture's own agent; a write still running answers 425 and is
1057
+ retried for five seconds, and an unconfirmed erasure is reported in the
1058
+ result, telling the agent the person can ask for that turn to be removed.
1059
+ - **A delete the service did not confirm counts as done** for capture: the
1060
+ text may already be gone. A forget made with no turn open marks nothing, a
1061
+ declined forget changes nothing, and the mark's life is its turn's (the
1062
+ flush spends it; the 24-hour bound is only a safety net).
1063
+ - **The result says only what happened.** "This turn isn't kept" appears
1064
+ only when a turn was marked (a background subagent's forget drops none),
1065
+ and the unconfirmed-erase sentence points at the consent path for a kept
1066
+ turn, not at the console page that cannot erase turns.
1067
+ - **A capture refused because its turn was erased is dropped, not
1068
+ quarantined.** `409 capture_tombstoned` deletes the spool entry with an
1069
+ id-only log line, so text the person asked to forget never sits in a
1070
+ quarantine file.
1071
+ - No tool description, schema or protocol text changed: the sentences are
1072
+ tool-result text.
1073
+
1074
+ - **The store takes every event kind the shared contract defines, and a
1075
+ refused event is never a silent drop** (DESIGN-jelly-sources §0.2, §2.3.1).
1076
+ The records service accepted nine kinds, so `jelly.files` (`file`),
1077
+ `jelly.routine-runs` (`x-jelly/routine-run`) and Memory's own
1078
+ `mem.suggestions` (`x-mem/suggestion`) were refused by `events.ingest` — and
1079
+ the contract's policy advances the cursor past `refused[]`, so those events
1080
+ were dropped and the cursor moved past them for good. The store's kind gate is
1081
+ now the vendored contract's own `isEventKind` (the contract's eleven kinds and
1082
+ every `x-<plugin>/<kind>` extension), carried inside the records service
1083
+ rather than copied by hand, with the copies held byte-identical by
1084
+ `check:copies` and `test/source-kinds.test.js`.
1085
+ - **A refusal is counted, shown and audited — the store's own.** Only an event
1086
+ the *store* refuses is a row of `event_refusals`, written in the page's own
1087
+ transaction: the source, the account, the event's id and kind, and the
1088
+ refusal's own sentence, never its title or text. `sources.list` reports
1089
+ `refusals: {count, at, newest_id, kind, reason}` for each binding from those
1090
+ rows. **A refusal the source plugin itself makes is not stored:** its
1091
+ `refused[]` entry travels in that run's result instead — the id and the
1092
+ reason — and is what `mem_spaces` health names, so it is never a silent drop
1093
+ and never a count alone, but there is no row to count later. Person erasure
1094
+ and `sources.unbind` delete the store's rows with the source's events;
1095
+ retention prunes them with the events they are about.
1096
+ - **The cursor follows the contract exactly as before:** `failed[]` holds it,
1097
+ `refused[]` (a page's, the consent's, or the store's) advances it, and every
1098
+ advance of that kind now leaves the trace above.
1099
+
1100
+ - **One collector per cell, and a holder that lost the lease stops before it
1101
+ writes (0.11 review, rounds 1–3).** The collector's lease let two processes
1102
+ both believe they held it: a re-acquire and a heartbeat read the record and
1103
+ then touched the path, so a takeover in between touched the new holder's file
1104
+ and the old holder went on collecting; a stale heartbeat alone allowed a
1105
+ takeover while the holder was alive (a blocked event loop, a machine asleep, a
1106
+ clock jump); and a release could unlink a new holder's lock. Beating and
1107
+ releasing now work through an open file (`fstat`, the record, `futimes`), and
1108
+ a beat's name is checked to still point at the same inode, so a beat can never
1109
+ count for another holder's lock; a release works through its own open file and
1110
+ inode, so it cannot briefly take another holder's lock off the path. A stale
1111
+ lease is taken over only when it is **abandoned**: its
1112
+ holder's process is gone (`kill(pid, 0)` on this machine); its pid is alive but
1113
+ is not the holder (it started after the lease was written, read from `/proc`
1114
+ or `ps -o lstart=`); or it has not beaten within the ceiling — now **half an
1115
+ hour**, 30 missed minute beats, where it was a day, because a holder that
1116
+ wakes after losing its lease stops rather than writing, so a short ceiling
1117
+ recovers a silent holder at the cost of a moment's overlap and never two
1118
+ collectors actually writing. A record from another host, or one whose start
1119
+ time cannot be read at all (Windows has no `/proc` and no `ps`), is judged by
1120
+ its heartbeat alone, as it always was. A holder that lost the lease checks
1121
+ before each binding's read and each page's ingest (`stillHolder`) and stops,
1122
+ leaving the status to the holder that has it, and the sessions write is fenced
1123
+ at its commit (`lock.held()`), so a displaced holder cannot rename stale
1124
+ sessions over the new holder's copy. `test/collector-lock.test.js` holds the
1125
+ unit cases (a live holder is never taken over; a dead holder's lease is taken
1126
+ over exactly once; a claim whose start time cannot be read ages out at the
1127
+ ceiling), two real processes contend for 50 rounds and never both hold it, and
1128
+ `CL-sessions-write-fenced` holds the commit fence.
1129
+
1130
+ - **One read budget decides every source read, whether Jelly's broker answers
1131
+ it or Memory reads it embedded (0.11 review N7–N8).** No deadline bounded an
1132
+ embedded declared-source read, and an older Jelly that answers nothing while
1133
+ its broker is off could hang a request and stall all collection — one read
1134
+ held the whole tick. `SOURCE_READ_TIMEOUT_MS` (30 s, fifteen times the records
1135
+ client's own read timeout and well inside the 30-minute cadence) now covers
1136
+ the embedded read and the broker both, the broker's own
1137
+ `BROKER_TIMEOUT_MS` is that same budget (`= SOURCE_READ_TIMEOUT_MS`, or the
1138
+ caller's), and the abort is passed in
1139
+ OpenCode's own shape (`{ signal: controller.signal }`), so a timed-out call is
1140
+ actually aborted and its parked request removed. On timeout the transport
1141
+ answers `{offered: true, ok: false, UNAVAILABLE}` with "jelly's broker did not
1142
+ answer in time, so nothing was read": the binding is held and retried on its
1143
+ next cadence, the run carries on with the other bindings, and a timeout is
1144
+ never an embedded read. One deadline covers a tick's broker reads
1145
+ (`resetBrokerTick`), so eight bindings cost one deadline rather than eight; an
1146
+ embedded timeout is bounded per plugin — the plugin that timed out holds its
1147
+ other bindings at once, other plugins are independent, and the next tick
1148
+ retries. The probe takes the same budget: `probeSource` copied the budget but
1149
+ not its name, so `timeoutMs` was undefined and **any** plugin whose answer
1150
+ took a moment failed its probe, which meant no declared source could bind
1151
+ (`BR-probe-binds-with-real-client-wiring`). And Memory's own deadline decides
1152
+ a timeout even when the plugin rejects the instant it is aborted, which is
1153
+ what OpenCode's adapter does: the deadline's callback now records that it
1154
+ fired, so a plugin's other bindings are still held rather than waiting out
1155
+ their own budgets (`BR-broker-timeout-holds-never-stalls`).
1156
+
1157
+ - **A revoke's preview names everyone who loses access, and reports a downgrade
1158
+ as well as a loss (0.11 review, `fix/acts-defects`).** A space-wide grant was
1159
+ counted twice in the preview's policy input — once as the grant and once as
1160
+ the person's space permission — so removing the grant that was somebody's only
1161
+ access answered `loseAccess: []` and `affected: 0`: the person confirming was
1162
+ told nobody loses access while someone did (an H2). Revoking a viewer member's
1163
+ editor grant answered the same way even though write access went, and
1164
+ contradicted the grant's own preview, which said they gained `write`. The
1165
+ preview now names every principal whose access drops, with what they had
1166
+ (`access`) and what they keep (`to`: `read` after `write`, `null` for a full
1167
+ loss), and `affected` counts both; it uses the person's membership role, never
1168
+ the grant-derived space permission. Names still follow the members and grants
1169
+ reads — the operator, the person, the grant's author or an admin of the
1170
+ target; someone the caller may not see is counted, never named; a group or
1171
+ role grant is named as that group or role, once per transition — and an agent
1172
+ grant is read with the agent's own role in its home space, capped by its
1173
+ owner's, so an agent that keeps access is not listed. Tests:
1174
+ `control/test/share-preview.test.js`, `test/share-revoke-preview.test.js`,
1175
+ `test/space-ops-gateway.test.js`.
1176
+
1177
+ - **A personal space's wiki can be previewed and deleted (0.11 review,
1178
+ `fix/acts-defects`).** `wiki.delete` and its preview read the wiki with the
1179
+ session's scope, not the space the input names, so the knowledge service was
1180
+ asked about another space's container and the gateway refused the named wiki
1181
+ at `/v3/wiki/page/ls` (403). Both now use the space's own scope (`wikiScope`,
1182
+ the helper `share.copy` already uses). The readers read the preview needs then
1183
+ refused a personal space (`personal_space`); it is a read, so it now answers
1184
+ for one — its owner by membership, and counts only for someone who reaches it
1185
+ through one of its page grants — while the join, handover and lifecycle routes
1186
+ keep refusing one. The preview also counted `pages` where the hub answers
1187
+ `items`, so it reported 0 pages for a wiki that had pages. The ask is
1188
+ unchanged: `wiki.delete` is `ask`, class `local`, always confirmed. Tests:
1189
+ `test/wiki-delete-personal.test.js`, `control/test/space-readers.test.js`.
1190
+
1191
+ - **An erasure reaches every row that holds the person, and rewrites nobody
1192
+ else's (`fix/erasure-coverage`, 0.11 review, rounds 9–11).** Five job tables
1193
+ (`job_items`, `job_curation`, `job_withdrawals`, `job_extracted`,
1194
+ `job_versions`) hold the person and had been classified person-free by hand,
1195
+ so they were never filled, scanned or erased; a table is now **personal when
1196
+ any column can hold a person** — an id (`user`, `owner`, `*_by`, `principal`,
1197
+ `actor`, `member`, `subject`, `reference`), a handle (`account`, `email`), or a
1198
+ column whose name says so — read from the schema rather than kept in a list,
1199
+ so a table added later cannot be missed. The proof's `auth.db` was
1200
+ hand-written, and Better Auth's verification row holds an address in
1201
+ `identifier`, not an id: it is now generated by the gateway's own
1202
+ `getMigrations` (better-auth 1.7.12 with the apiKey plugin) and the connect and
1203
+ capture tables come from the gateway's own factories, and a purge matches a
1204
+ row whose `identifier` or email is the person's address, read from their user
1205
+ row before it goes. A real source or job stores the external account owner
1206
+ (`google:<address>`), so keying only on the Memory user id erased nothing;
1207
+ every id form a row carries is matched — the Memory id, the core's upstream
1208
+ id, the external owner, and the Memory-side link — and the rule covers row
1209
+ text and JSON (`run`, `value`, `diff`, `identifier`), not only columns. The
1210
+ last round found the opposite harm: the `job_versions` scrub walked every row
1211
+ in the space and replaced every `label`, so another person's job spec and a
1212
+ team channel label became "former-member". It now reads only the person's own
1213
+ jobs and rewrites by path — the owner's id and label, the account, and a JSON
1214
+ patch's `/owner` and `/account` — leaving another person's spec byte-identical.
1215
+ A bound source with no job is not found today because sources are personal
1216
+ only, so that file is deleted whole; the runbook says so and it is revisited
1217
+ when shared sources ship. Tests: `test/account-erasure-coverage.test.js`
1218
+ (`EC-*`), `-postgres`, `-restore`.
1219
+
1220
+ - **A handover asked for by someone who is not the owner says it is a request,
1221
+ and the agent's page read marks a missing link only where that reader can know
1222
+ (the 0.10.5 gate's B10 and A5; `fix/handover-links`).** The server's handover
1223
+ preview is written as the person who may perform it, so an editor was told "you become an admin",
1224
+ and the result said "the space's owner confirms" with no name — which the agent
1225
+ filled with an invented one. The preview and the result now follow the caller's
1226
+ role: for anyone who is not the owner they say this sends a handover **request**
1227
+ that the space's owner confirms in the console, and they **name that owner only
1228
+ when the caller can see them**, else say the owner is not visible to the
1229
+ caller; a `members` row marks the owner the same way ("owner: not visible to
1230
+ you"). Production lets only the owner preview or hand over — a non-owner's call
1231
+ is refused `403` — and that refusal was rendered as "memory unavailable: not
1232
+ handed over: SPACES_FORBIDDEN: …", which reads as an outage: **a 403 from
1233
+ control is now shown as its own refusal**, in its words, with its next step and
1234
+ no code envelope, while a 5xx or a transport failure still answers "memory
1235
+ unavailable". On the agent's own page read — `mem_page` `read`, and the Jelly
1236
+ twins that call it — a `[[path]]` outlink whose target has no page in the space
1237
+ is marked `[[path]] (no page yet)`, from one bounded
1238
+ `records.get` for its distinct links (50, the store's own limit) — but the
1239
+ store reports `missing` both when a page does not exist **and** when the caller
1240
+ cannot read it, so **a mark is made only where that reader can know the page is
1241
+ missing**: a reader holding space-level read (not a page `grant`, not the role
1242
+ `grant`) sees it, and **a link that is grant-only or otherwise unreadable is
1243
+ left unmarked**, so the agent's read never reveals whether a page it cannot see
1244
+ exists; a failed lookup marks nothing rather than call an existing page
1245
+ missing. No tool description changed (always on 10,247; direct tools 27,473).
1246
+ Tests:
1247
+ `HO-preview-for-non-owner`, `HO-result-names-confirmer-or-not-visible`,
1248
+ `HO-members-owner-visibility`, `HO-production-refusal-shown`,
1249
+ `PL-missing-link-marked`, `PL-existing-link-unmarked`,
1250
+ `PL-grant-only-reader-no-false-absence`, `PL-unreadable-target-unmarked`.
1251
+
1252
+ - **Jelly's Pages view says only what the reader can know about links.** It showed "<target>: no page yet" for a page that exists when the reader held only a grant, or when the lookup failed. It also showed "Nothing links here yet." when the backlinks lookup failed (0.9.14 has the same view). The view and the agent's page read now share one rule (`src/outlinks.js`):
1253
+ - `pages.read` omits `outlinks[].exists` when existence can't be known; the field is now optional in the declared schema;
1254
+ - a failed backlinks lookup fails the read;
1255
+ - a reader without space-level read sees backlinks worded as theirs to see ("Nothing you can see links here."; the agent's page read says "Backlinks you can see: none").
1256
+
1257
+ Space-level read counts only for the roles viewer, editor, admin and owner.
1258
+
1259
+ ### Checks
1260
+
1261
+ - **The eval's write allowlist flags the seven jobs writes** (`jobs.draft`, `run`, `pause`, `resume`, `archive`, `activate` and `remove`), as 0.11's does, so a release gate shows them to its adjudicators. 0.10's `mem_spaces` already offers these operations.
1262
+
1263
+ The lanes that change tests and CI only, each merged into `build/0.11`, with no
1264
+ product change of its own:
1265
+
1266
+ - **A paced Linux loop of the lock tests is the lock's judge**
1267
+ (`ci/collector-lock-loop`). `.github/workflows/collector-lock-loop.yml` runs
1268
+ `.github/scripts/paced-lock-loop.sh` — the lock and race tests under a real
1269
+ pace, on ext4 and on overlayfs, and 200 runs of the race tests on a 2-CPU
1270
+ overlayfs — on every pull request into `build/*` too. The local two-owner
1271
+ failure that started it was a test artefact, diagnosed and fixed with review;
1272
+ the fixed tests still fail against the pre-fix code.
1273
+ - **CI's PostgreSQL job retries the client fetch** (`ci/postgres-resilient`)
1274
+ instead of failing the job when the first fetch misses.
1275
+ - **The acts gate harness** (`feat/acts-gate-harness`): every press carries the
1276
+ person's own credential, names its host, and carries exactly the input Jelly
1277
+ previewed — `test/acts-gate-classes.test.js`, `-ops`, `-p1`, `-scenarios`,
1278
+ `test/p2-gate.test.js`, `test/support/acts-gate-world.js` and
1279
+ `test/support/jelly-host-standin.js`, written up in
1280
+ [docs/acts-gate-harness.md](docs/acts-gate-harness.md).
1281
+ - **Every declared view read runs against the real services**
1282
+ (`test/declared-reads-real`): `test/views-declared-reads.test.js` holds each
1283
+ one against the real records service and control, not a stub.
1284
+ - **The eval fixes the gate asked for** (`fix/eval-scenarios`): the two known
1285
+ scenario defects — a wiki delete whose wiki was never seeded, and a handoff
1286
+ item a page's own body could satisfy — and a held team write made observable
1287
+ to the gate's reader.
1288
+ - **Three flake fixes, each about a test's own clock**
1289
+ (`fix/console-degraded-flake`, `fix/shutdown-race`,
1290
+ `fix/forget-turn-flake`): a busy runner no longer times the fixture's own
1291
+ control call out, the shutdown deadline is the test's clock and not the
1292
+ runner's, and the forget's delete keeps its fast timers' arguments.
1293
+
1294
+ ### Docs
1295
+
1296
+ - **The core and hub images are named by the Docker Hub tag they carry,
1297
+ `1.0.0`, not `2.0.0-beta.1`, a tag neither image publishes**
1298
+ (opencode-mem#86, point 2, stage A). `SECURITY.md` and `docs/architecture.md`
1299
+ name `1.0.0` beside each image id and add that no upstream commit is
1300
+ published for these images: they carry no revision label, the vendor
1301
+ publishes no source repository, and so the pin stays by image id. Upstream
1302
+ has since published `1.0.1`, `1.0.2` and `1.0.3`. The dated records under
1303
+ `docs/audit/` are unchanged; `docs/deployment.md` and the `session/add` row
1304
+ follow the same tag.
1305
+
1306
+ ### Deploy
1307
+
1308
+ **Jelly 0.4.0-beta.20 or newer (protocol major 7) is required for the plugin.**
1309
+ An older Jelly refuses the 34-action declaration whole as a schema error
1310
+ (`actions: Too big: expected array to have <=32 items`); upgrade Jelly before
1311
+ the 0.11 plugin.
1312
+
1313
+ **Records first, then control and the gateway, then the plugin and the console.**
1314
+
1315
+ **The records schema moves, forward only: `SCHEMA_VERSION` 5 → 7.** Opening a
1316
+ space file with 0.11's records service raises its `schema_version` to 7 and runs
1317
+ two steps: **6** adds `sessions_seen` (one row per OpenCode session, with which
1318
+ side saw it first) and `events.session_id` / `events.curated_by` with their
1319
+ index, and **7** adds `binding_resyncs.cursor`. **The irreversible step is that
1320
+ raise itself:** a records service that opens a space file writes version 7 into
1321
+ it, and a 0.10 records service then refuses that file — `records: this space
1322
+ file has schema version 7, newer than this service (5); upgrade the service` —
1323
+ there is no migration back, so rolling the records
1324
+ service back means restoring every space file it opened from backup, taken
1325
+ before its first start. Roll records forward to 0.11 across the whole cell
1326
+ before any other component, and do not start 0.11 records on a cell you may
1327
+ have to roll back.
1328
+
1329
+ **Two columns are added without a migration step.** When 0.11's records
1330
+ service first opens a space file, after the `ADDITIVE` tables it also adds
1331
+ `source_collections.more` (so the collector can report that a run left pages
1332
+ behind on Sources) and `sources.asked_account` (the account a binding was asked
1333
+ with, so a re-key supersedes only its own ask and a person's named accounts are
1334
+ never stopped by one another) — both nullable, both by `ensureColumns`,
1335
+ `records/src/schema.js`. `MIGRATIONS` is unchanged and `SCHEMA_VERSION` stays 7:
1336
+ nothing is rewritten and no version moves. **Neither column changes what a
1337
+ rollback costs.** A 0.9.14 records service refuses any space file that 0.11 has
1338
+ opened — its `SCHEMA_VERSION` is 5 and `migrateVersions` throws `records: this
1339
+ space file has schema version 7, newer than this service (5); upgrade the
1340
+ service` — so rolling records back means restoring every space file from the
1341
+ backup taken before 0.11 first opened it, as the paragraph above says.
1342
+
1343
+ **Control's migrations are 020 to 026**, and every one has its twin under
1344
+ `control/migrations/postgres/`, so SQLite and PostgreSQL move together — the
1345
+ schema is the same version on both:
1346
+ 020 `spaces_flavor_visibility`, 021 `space_requests` (join and handover
1347
+ requests), 022 `space_requests_one_transfer`, 023 `act_reservations` (P2),
1348
+ 024 `account_erasure`, 025 `agent_credential_erasure_reason` (the
1349
+ `account_deleted` reason the existing CHECK refused, so the table is rebuilt),
1350
+ and 026 `deleted_accounts_issuer` (the PostgreSQL half of 024 was keyed on
1351
+ `subject` alone and failed every erasure with `42703`; on SQLite the key was
1352
+ already right and the step is a no-op).
1353
+
1354
+ **What is dark, and what a cell that sets nothing sees.** The declaration is
1355
+ static: **34 actions**, every act this build wires, under Jelly's 48-action cap.
1356
+ An act changes nothing until **both action switches** are on: the plugin's
1357
+ `actions` option (`MEM_ACTIONS`, default `false`, so every press answers
1358
+ `ACTIONS_OFF`) and records' `RECORDS_ACTIONS_ENABLED` (empty, so every act
1359
+ answers `grant_action`). The four P2 acts need one more thing:
1360
+ `P2_RESERVATION_KEY`, the same value in records (which signs the reservation),
1361
+ the gateway and control (which verify and spend it). **A cell that sets no P2
1362
+ key** issues no reservation, and a press of `share.transfer`, `share.decide`,
1363
+ `space.visibility` or `space.manage` refuses `P2_UNAVAILABLE`, naming the
1364
+ secret and the three services, before control is asked — not a misleading
1365
+ `NEEDS_APPROVAL`. The gateway's key puller still needs `ACTION_KEYS_FILE` (the
1366
+ file the puller writes and records reads). Erasure is off until Jelly ID's feed is
1367
+ configured (`ACCOUNT_FEED_CONTROL_URL` and Memory's own service key at the
1368
+ gateway, plus each cell's pinned records credential and
1369
+ `RECORDS_ERASE_KEY` ⇄ `CONTROL_RECORDS_ERASE_KEY`), so a cell that sets none of
1370
+ them erases nothing and behaves as 0.10.x. **If you do turn the feed on, place
1371
+ `CONTROL_ERASED_FILE` outside control's backup set** (compose mounts its own
1372
+ volume at `/var/lib/control-erased`): it is the second store of erased
1373
+ identities, and restoring control must not roll it back —
1374
+ [docs/operations/account-erasure.md](docs/operations/account-erasure.md) has the
1375
+ settings, the `auth.db` boundary and the backup windows.
1376
+
1377
+ The source contract is the vendored pre-tag copy, not the tagged release: the
1378
+ tag does not exist yet, so `npm run tag:check` fails by design until it does and
1379
+ is not one of the pre-checks (the freeze checklist says why).
1380
+
1381
+ ## [0.10.6] - not released
1382
+
1383
+ **Never released.** Its two fixes — a truthful non-owner handover, and a link marked
1384
+ missing only where the absence is knowable — ship in 0.11, under 0.11’s own
1385
+ entries above.
1386
+
1387
+ ## [0.10.5] - not released
1388
+
1389
+ **Never released.** Its gate passed (`VERDICT PASS`), and its candidate is the
1390
+ one `build/0.11` was cut from — `b74f3a40`, gate candidate `7858d077`, merged at
1391
+ `3ac0fa5b` — so its fixes ship in 0.11 and are not a release of their own. It
1392
+ carried 0.10.4, never released either: its gate found two wrong answers about
1393
+ what memory holds — one where a hit stated the answer in other words and the
1394
+ agent said it was not recorded (A1), and one where a space's collected events
1395
+ went unmentioned on a miss (A16) — which this section fixes.
1396
+
1397
+ ### Fixed
1398
+
1399
+ - **A hit that states the answer in other words, or for a named part, is the
1400
+ answer.** The recall guidance says so, to give it with its scope and its id —
1401
+ unless the question names a different part — and to say "not recorded" only
1402
+ when no hit states it. A hit that only mentions the subject without stating the
1403
+ asked fact is not the answer: it is cited as what it does say, and the answer is
1404
+ not recorded. A worked example shows the other-words case, and is dropped rather
1405
+ than crowding an answer when the result has little room.
1406
+ - **A space's collected events are mentioned when they matter.** On a miss, and
1407
+ only beside no answer, the result says how many collected events the space
1408
+ holds, from which source, and that recall cannot read them yet, so the agent
1409
+ neither claims the answer is there nor says it is not in Memory. The line stays
1410
+ away from a stated answer and from browsed records, where it would compete with
1411
+ what was found.
1412
+ - **"Last collected" is named only from a successful collection.** A collection
1413
+ that failed says the time it was recorded as unknown, instead of presenting a
1414
+ failed attempt as when Memory last read the source.
1415
+
1416
+ ## [0.10.4] - not released
1417
+
1418
+ **Never released:** its gate found two wrong answers about what memory holds — a
1419
+ hit that stated the answer in other words read as "not recorded" (A1), and a
1420
+ space's collected events unmentioned on a miss (A16) — which 0.10.5 fixes. It
1421
+ carried 0.10.3 — never released either: its gate found four wrong answers, each
1422
+ stating a fact no tool had returned. Its entries are kept below, marked not
1423
+ released, and ship in 0.10.5.
1424
+
1425
+ ### Fixed
1426
+
1427
+ - **A commitment says it is new.** After an `add`, the open list marks the record
1428
+ it just wrote "(just added)", so it does not read like one that was already
1429
+ there, and a due-list row for something added in this conversation says
1430
+ "(added in this conversation)". A duplicate add says "already open, so nothing
1431
+ was added", and its existing record is marked "already open, nothing added".
1432
+ - **`members` says which one is you.** The person's own row is marked ", you"
1433
+ inside its role, and — only when their row was found — an "other members: N"
1434
+ count follows. When the roster cannot be matched to the person, no one is
1435
+ marked, no count is given, and nothing is claimed about who is in the space.
1436
+ - **A failure shows its real message, redacted.** The answer carries the message
1437
+ the service or the source actually gave, with secrets taken out: private keys,
1438
+ cookie values, a URL's query string and fragment, userinfo, Memory's own secret
1439
+ patterns, random-looking tokens, and long hex runs. When anything still looks
1440
+ secret, the message is withheld rather than shown, and no failure reads as an
1441
+ empty object.
1442
+ - **`health` says collected events are not recallable.** When events have
1443
+ arrived, it says recall does not read them and that only a routine turns them
1444
+ into proposals or journal pages, so a failed collect does not read as "it
1445
+ never arrived".
1446
+
1447
+ ## [0.10.3] - not released
1448
+
1449
+ **Never released:** its gate found four wrong answers, each stating a fact no tool
1450
+ had returned, which 0.10.4 fixes. It carried 0.10.2 — also never released: its
1451
+ gate found one H2, an unscoped absence claim (`suite-lifecycle`
1452
+ `life-archive-asked#3`), the mirror of 0.10.1's, where 0.10.2 scoped an absence
1453
+ claim for a recall in a shared space but a recall in the person's own space still
1454
+ supported "nothing in memory records a rule". Its entries are kept below, marked
1455
+ not released, and ship in 0.10.5.
1456
+
1457
+ ### Fixed
1458
+
1459
+ - **A recall miss says which scope it holds for, and names the spaces it did not
1460
+ read** (0.10.2 gate, `suite-lifecycle` `life-archive-asked#3`, H2). The person
1461
+ asked what archiving the Shared Workspace memory space does, and to see it
1462
+ first. One `mem_recall` — a task, and its session's own space — missed, and
1463
+ the answer said "nothing in memory records a rule about that either way",
1464
+ while the Shared Workspace, where a team rule lives, was never searched. The
1465
+ result said "only one scope was searched", which names no space and offers no
1466
+ next step, so the claim about memory survived it.
1467
+ - **On a miss**, in the person's own space, a task scope, or a page grant, the
1468
+ result names the scope it searched and the spaces it did not read — at most
1469
+ five names, then "and N more" — and says that "not recorded" holds only for
1470
+ the searched scope: **"say so, or search a space the person named"**. The
1471
+ scoped claim is the fix; it never sends an agent to a space the person did
1472
+ not name (protocol rule 1, review S2). A shared-space miss keeps its 0.10.2
1473
+ sentence, which already names the private memory it never reads.
1474
+ - **A personal-space hit now bounds the claim too** (review S4): 0.10.1's H2
1475
+ was a hit on another topic, and only a shared space had a hit line. It now
1476
+ says *the person's own memory only: "not recorded" holds for it alone* — no
1477
+ names and no invitation, so it costs no call and reads no space list. It
1478
+ appears on any personal-space hit in control mode, whether or not the person
1479
+ can reach another space.
1480
+ - The space list is read at most once, on a miss, and never on a hit; local
1481
+ direct mode has one fixed scope, so it lists nothing. A note that says the
1482
+ scope "was searched" needs a search that answered: a failed layer makes the
1483
+ result incomplete, not empty, so the note stays away (review N1).
1484
+ - **A space name is neutralised before it reaches the note** (review S1). A
1485
+ name is set by another member of the organisation, and a probe showed
1486
+ `</recalled_memory>` passing through: names now take the same fence
1487
+ neutralisation as the scope label beside them.
1488
+ - The empty-scope ban beside the note says "Do not search *this space* again",
1489
+ so the search the note offers is not forbidden. The person's own space now
1490
+ follows the same rule as a shared one.
1491
+ - **The protocol is unchanged.** Rule 2's "If no record states it, say so" read
1492
+ as "say memory has nothing", and keeping both meanings — say so, and where
1493
+ you looked — costs more characters than the block has: the scoped wording
1494
+ needs 22 more and 7 are free (the wrapped block is 1,443 of the surface
1495
+ budget's 1,450; the block itself 1,412 of 1,425), and every trim available
1496
+ dropped a rule's scope ("this session") or a rule's subject. So rule 2 keeps "say so", and
1497
+ the scope is carried where it is free: the recall result's own miss text
1498
+ ("If no rule is found, say it is not recorded in this scope") and the note
1499
+ above. Sizes are 0.10.2's: block 1,412 of 1,425, wrapped 1,443 of 1,450, the
1500
+ direct tools 27,473 of 27,500, and no description or schema changed.
1501
+
1502
+ `test/recall-tool.test.js` holds it: a personal-space miss, a task scope, a
1503
+ page grant, the five-name bound, a personal-space hit, a hostile space name,
1504
+ an unreadable space list, a failed layer, and the shared-space line unchanged.
1505
+
1506
+ - **A page's owner is named, on the page and in every listing.** The field
1507
+ shipped in 0.9.14 — `owner {id, name}` on `pages.read` and on each `pages.list`
1508
+ row — never appeared: it matched the record's `owner` against control's member
1509
+ roster by equality, and those are two different ids. A record's owner is the
1510
+ core's **upstream** user id (what the gateway sends as `x-records-user`, from
1511
+ `context.user.upstream_id`), while control's roster knows a person by its own
1512
+ `user_id` (`usr_…`), so nothing matched and every page carried no owner at all.
1513
+ It failed closed — no wrong name — but Jelly drew no owner anywhere. The roster
1514
+ now carries each member's upstream id too (control's member listing, both
1515
+ stores, and the gateway's roster read; the console's own member answers and the
1516
+ context's `user` still never carry it), and the view matches a record's owner
1517
+ on the one id that person's records are written under: their upstream id, or
1518
+ their own `user_id` when control has none. `owner.id` is control's `user_id`:
1519
+ the person's own id everywhere else (the space's members read), and the only one
1520
+ Jelly can relate to a member it draws; the upstream id is the core's own name
1521
+ for that person and no view answer shows it. Visibility is unchanged — a name
1522
+ only where the caller can see that member through the space's roster — so a
1523
+ reader holding only a page grant is still told no owner, a record owned by
1524
+ another person whose upstream id equals a member's `user_id` names nobody, and
1525
+ a routine's pages name no one. No agent-facing text changes.
1526
+
1527
+ ## [0.10.2] - not released
1528
+
1529
+ **Never released:** its gate found one H2, an unscoped absence claim
1530
+ (`suite-lifecycle` `life-archive-asked#3`), which 0.10.3 fixes. It carried
1531
+ 0.10.0 and 0.10.1, neither of them released either: 0.10.0 closed a commitment
1532
+ correctly and then invented two open ones, and 0.10.1 deleted a page the person
1533
+ never asked to remove and, by the coordinator's second read, said their memory
1534
+ held no note of a plan it did hold. Its entries below are kept and marked not
1535
+ released, and they ship in 0.10.5.
1536
+
1537
+ ### Added
1538
+
1539
+ Three reads Jelly asked for on #58 (its asks 2, 3, 4 and 6). They are view reads
1540
+ (the plugin's declared `rpc` in its jelly declaration), so no agent-facing text
1541
+ changes and no budget moves: always-on stays ≤ 10,500 and direct ≤ 27,500.
1542
+
1543
+ - **`names.known`, for dictation.** A new read under `mem_page`, capped at 50,
1544
+ answering `{names: [{name, kind, aliases?}], more, incomplete}`: the titles of
1545
+ the person's people, project and team pages, and their glossary entries
1546
+ (`term`), with the aliases a page's own `fields.aliases` names. Ordered
1547
+ deterministically — the most referenced name first (the pages of the same read
1548
+ that link to it), then by name — and carrying no space id and no path, so a
1549
+ dictation vocabulary is what a person would say. Each list read asks the
1550
+ service for those four page types only, so an old people page is still a name
1551
+ in a space of newer journals, and follows the cursor for up to five 200-row
1552
+ pages per space; a space past that, a glossary past its bodies, or more names
1553
+ than one answer holds sets `more`, so the list is never cut silently. Read
1554
+ only over the spaces control lists for the caller, each on its own, and only
1555
+ the pages the caller may read: a space that cannot be read is named in
1556
+ `incomplete`, and a page outside a page grant contributes neither a name nor a
1557
+ link count.
1558
+ - **`community` on each `graph.links` node (Jelly's ask 2).** A deterministic
1559
+ grouping of the answer's own pages by their links, so a host can colour the
1560
+ graph: the nodes are put in one canonical order (by path, then id) and their
1561
+ edges follow, then label propagation for at most 8 rounds, ties to the
1562
+ smallest label, numbered by first appearance. Computed on every read and never
1563
+ stored; the same graph gives the same grouping whatever order the service
1564
+ returned it in, the work is bounded by the answer's own node and edge caps, and
1565
+ because it reads only the nodes and edges already in the answer, a community
1566
+ can never reveal a page the caller cannot see — including in a page-grant
1567
+ space, whose reads return only the granted rows. The algorithm is documented in
1568
+ `docs/jelly.md` ("Communities in a graph").
1569
+ - **`grantOnly` on a space (Jelly's ask 4, its #49 answer 8).** `spaces.list`'s
1570
+ rows and every `space` a view read names say whether a write there waits for a
1571
+ grant, so a host can say "this waits for you in the Inbox". It is `false` for
1572
+ every space from one named constant (`SPACE_GRANT_ONLY`): Memory holds no write
1573
+ for a grant yet, and the field is declared now so the answer does not change
1574
+ shape when a held-write policy lands. A tool's receipt (`metadata.memoryReceipt`)
1575
+ is display data, not a view schema, and keeps its own space shape.
1576
+
1577
+ ### Fixed
1578
+
1579
+ - **An agent deletes or forgets only what the person asked to remove; its own
1580
+ mistake is reported, not tidied** (0.10.1 gate, jelly-core
1581
+ `core-wiki-write#2`, H3). The person asked for a wiki. The agent first made a
1582
+ personal page by mistake, then deleted that page and its history on its own:
1583
+ only the eval's automatic ask-broker had approved the `page.delete` ask, and
1584
+ the person never asked for a delete. An unasked delete or forget is harmful,
1585
+ whoever approved the ask.
1586
+ - Protocol rule 4 said "Ask first to delete, forget or replace unnamed items",
1587
+ which read as permission to ask. It now says **"Delete, forget or replace
1588
+ only on request; no tidy-ups"**: the consent is the person's request, and
1589
+ an agent does not tidy up after itself.
1590
+ - The narrow detail the always-on block cannot afford — *say so, and offer to
1591
+ remove it* — is at the delete itself: the `mem_page` and `mem_wiki`
1592
+ `confirm` arguments now say a delete is only on the person's request (the
1593
+ wiki one adds: "Pass true only when the person asked; one you propose is
1594
+ offered, never deleted"); so do the `mem_page` and `mem_wiki` delete
1595
+ previews, the `mem.usage` and `mem.pages` skills, and the protocol
1596
+ document's "Deletes" line.
1597
+ - The block is 1,412 of its 1,425 characters (1,443 of 1,450 wrapped); the
1598
+ always-on surface is 10,247 of 10,500 and the direct tools 27,473 of
1599
+ 27,500.
1600
+ - `memory.forget`, `wiki.delete` and `page.delete` keep their ask, unchanged.
1601
+
1602
+ - **A recall says which memory it searched, so "not recorded" can only name
1603
+ that scope** (the 0.10.1 gate's second read, `hand-note-no-private#4`). The
1604
+ person asked for a handoff note on the team's Harbour page; their own memory
1605
+ held "Next week I finish the PDF export spec for Harbour", but the session's
1606
+ space was the shared one, so no recall read the private space, and the agent
1607
+ told them "memory has no note of your plans" — a definite absence no search
1608
+ supported. A recall whose space is shared (or reached by page grant) now
1609
+ carries one line. A result with a hit bounds the claim:
1610
+ `Shared space: only this space was searched, not the person's private memory,
1611
+ so "not recorded" holds for this space only.` A result with no hit also says
1612
+ how, so the next step is one call and not a guess: `Shared space: the
1613
+ person's private memory was not searched. Search it with visibility:
1614
+ "private" before saying it is not recorded.` Both lines turn on a memory hit
1615
+ (records, atoms or past turns); a document index does not count, because a
1616
+ space with one always renders a `<knowledge>` fence, even with no hit, and a
1617
+ failure block when the search fails. The empty-space instruction is
1618
+ scoped the same way: "Answer that it is not recorded in this space". The
1619
+ person's own space, an unbound shared default (which reads personal) and local
1620
+ direct mode carry neither. Tool-result text only: no tool description,
1621
+ schema, skill call shape or the always-on protocol changed (still 1,443
1622
+ characters wrapped), and the note is taken out of the same per-recall budget
1623
+ the coverage line is. What goes onto a shared page is unchanged: the fix only
1624
+ makes the agent look in the person's own memory, and the team-page rules
1625
+ still decide what it may write there. `test/recall-tool.test.js` covers a
1626
+ shared miss and a shared hit, every `in:` value, `visibility: "team"`, an
1627
+ explicit shared or personal space, an unbound shared default, local direct
1628
+ mode, a private recall with no line, and a private recall that serves the plan
1629
+ the shared one never saw; `test/records-asks.test.js` covers the page grant,
1630
+ and `test/recall-tool.test.js` also covers a shared space with a wiki: no hit,
1631
+ a failed search, and a real document hit all keep the miss line.
1632
+
1633
+ ### Checks
1634
+
1635
+ - Tests first: `test/views-names.test.js` and `test/views-communities.test.js`
1636
+ cover both reads, their visibility (only the caller's spaces are read; a hidden
1637
+ page changes no community and appears in no name), determinism, ordering and
1638
+ the caps; the contract, speaker and end-to-end view suites cover `grantOnly`.
1639
+ - `JELLY_REPO=~/hey-jelly npm run check:jelly:master` passes against Jelly's
1640
+ `origin/master`, and no field is held back: none waits on a Jelly reader.
1641
+
1642
+ ## [0.10.1] - not released
1643
+
1644
+ **Never released:** its gate found two decisive harmful events — an unasked
1645
+ delete (H3, `core-wiki-write#2`), and an unscoped "not recorded" claim the
1646
+ coordinator's second read made H2 (`hand-note-no-private#4`), which 0.10.2's
1647
+ scoped-recall branch answers. It carries 0.10.0 — also never released, its gate having found one wrong answer (a
1648
+ commitment closed correctly, then two open ones invented). Its entries — 0.10.0's
1649
+ grants S1, the space lifecycle, Memory Jobs J0 to J4, the plugin kit and plugin
1650
+ declarations, plus the commitment-result fix and two eval-harness
1651
+ corrections — ship in 0.10.5.
1652
+
1653
+ ### Added
1654
+
1655
+ - **Memory Jobs J4: curation into memories and the graph (proposals only).** The
1656
+ extract stage reads what a job collected and proposes memories, commitments
1657
+ and graph entities; every proposal waits for review (a person's accept is the
1658
+ console's, as for any held write), and a run never writes a memory directly.
1659
+ **`extract` is off by default** (`RECORDS_JOBS_EXTRACT`), so a job stores
1660
+ what it reads and curates nothing until an operator turns it on.
1661
+ - **Attribution is a rule, not a pattern list.** In the person's own verified
1662
+ message a first-person promise is theirs only above the first
1663
+ reply-boundary line and on a line that names no other person; otherwise it
1664
+ is withheld and counted, never proposed. False negatives are accepted,
1665
+ false positives are not: a relayed block that names somebody and ends in
1666
+ `:` is never the person's.
1667
+ - **The payment guard is Jobs only.** A line that carries payment context is
1668
+ dropped from what the extractor may propose; Routines keep their own rule
1669
+ and `decisionKind`, unchanged.
1670
+ - **Decision markers are Jobs only.** `Outcome:`, `Resolution:`, `Decided:`,
1671
+ `Conclusion:`, "agreed with <X>:" and a present-tense "we <verb> … on/by
1672
+ <date>" mark a decision; a hedge or a question is not one.
1673
+ - **The eval** (85 labelled units, run by the J4 lane with the gate's model)
1674
+ prints the counts each run.
1675
+
1676
+ - **Verified-caller grants, dark (S1).** An action-grant verifier and its key
1677
+ file (`src/action-grant.js`, `records/src/action-grant.js`), the gateway's
1678
+ verified-caller identity headers (`x-records-identity-issuer`,
1679
+ `x-records-identity-subject`, `x-records-principal`), `acts.apply` as a
1680
+ write, and the records service's `act_grants` ledger: one row per grant
1681
+ spent, in the same transaction as the act, so a second use fails and rolls
1682
+ back. The verifier fails closed on the declaration, the API-key issuer and
1683
+ the check order, and notices a key file swapped in with its mtime and size
1684
+ intact. Nothing calls it yet: the verifier is dark until a later slice
1685
+ turns it on.
1686
+ - **The space lifecycle (S1, S2).** `mem_spaces` gains create, rename,
1687
+ archive (and restore), leave and handover, each asking the person: create,
1688
+ rename and unarchive are G1 (a setting may lift the ask); archive, leave
1689
+ and handover are G2 and never skipped, and each carries `expected_digest`,
1690
+ the digest of the state the preview showed, so a space changed behind the
1691
+ preview is refused. Handover is a request the person confirms in Memory's
1692
+ console. The console's Spaces area adds a new space, rename, leave, make
1693
+ owner, a danger zone and a deletion request (G4). The gateway gains one
1694
+ path-id decoder for every route, so a decorated id (`agt_1%20`) is refused
1695
+ rather than trimmed into another agent's, and self-leave's bypass is closed.
1696
+ Eval: lifecycle suite `2026-11-13.3`, 9/9.
1697
+ - **Memory Jobs J0 to J2.** `mem_spaces jobs` lists, reads, drafts, runs now,
1698
+ pauses, resumes and archives a scheduled pipeline; a draft never runs, and
1699
+ activating or deleting one answers with the console link where only the
1700
+ person can act. A job reads a source the way its connector's declaration
1701
+ says (schema v2), a consent names its version, a paused consent stays
1702
+ paused, and approval of a consented digest is a console session's. No
1703
+ collected text can draw an image. New asks: `job.run` and `job.resume`
1704
+ (G1), `job.archive` (G2).
1705
+ - **The plugin kit (schema v2).** Memory's connector schema v2, a kit and a
1706
+ check, with one command that runs the examples and the kit's tests
1707
+ (`plugin-kit/`): read verbs on operations, no joined names, no extra
1708
+ grants, exact grants after the calls.
1709
+ - **Plugin declarations, read-only (plugin-declared Memory, slice S1).** Memory
1710
+ reads each installed plugin's `package.json#memory` from disk (OpenCode's
1711
+ plugin store for package plugins, `<path>/package.json` for local ones),
1712
+ validates it against the fixed frame (`memory-plugin.v1`: the schema, the
1713
+ read-verb allowlist and the write-verb check on every token), compares an
1714
+ optional `<plugin id>.memory/manifest` RPC byte for byte, and reports each
1715
+ plugin's state to the records service (`plugins.report`, `plugins.list`).
1716
+ The console's Sources page lists them as Available, Invalid, Unverified,
1717
+ Conflict or Missing (a plugin the last full report no longer names). One
1718
+ bad declaration is invalid on its own; the rest of the report is kept. When no package plugin can be found, it says "OpenCode changed its
1719
+ plugin store; update Memory". Nothing is collected from a declaration yet:
1720
+ the collector and the source registry are unchanged, and plugin text never
1721
+ enters a prompt.
1722
+
1723
+ ### Fixed
1724
+
1725
+ - **A commitment change says what is still open, so an agent has nothing to
1726
+ fill in** (the 0.10.0 gate's H2, `tool-commitment-close#3`, jelly-tools). The
1727
+ gate found the agent closing a commitment correctly with
1728
+ `mem_commitments` `update` (state `done`), then telling the person "Your open
1729
+ list now holds two items: Sam — activation walkthrough (Fri 13 Nov); Rowan —
1730
+ agent eval write-up (Fri 20 Nov)." No tool returned those, and the store held
1731
+ no other open commitment: the answer said only what changed, so the list was
1732
+ invented. Now every `add`, `update` (any state) and `delete` answer ends with
1733
+ the state of the person's own scope: `Open now: 2 — "Agent eval write-up"
1734
+ (Rowan, Fri 27 Nov); "Activation walkthrough" (Sam, Fri 20 Nov).` — the count,
1735
+ up to five items (what, owner, due; the latest due date first, undated last,
1736
+ and `and N more` past five) — or `No other open commitments.` when none is
1737
+ left. It is read from the same private scope `list` reads, so another space's
1738
+ commitments never appear. Tool-result text only: no tool description or
1739
+ schema changed, and the always-on and direct budgets are the same (10,244 and
1740
+ 27,497 characters). `test/commitments-open-result.test.js` covers a close
1741
+ that leaves none, one that leaves two, seven open counted at five, a delete,
1742
+ and another space that stays out.
1743
+
1744
+ ### Evals
1745
+
1746
+ - **The gate's harness reads the fake control's lifecycle endpoints, and stores
1747
+ a rename** (`audit-reports/gate010/SECOND-READ.md`). `observedWrites`
1748
+ (`scripts/eval/write-allowlist.mjs`) now lists
1749
+ `space.handover_requested` beside the other lifecycle endpoints, and
1750
+ `scripts/eval/harness-control.mjs` keeps a renamed space's new name, so a
1751
+ scenario's rename is read back as it happened. Eval mechanism only: no
1752
+ product code, no tool, no schema.
1753
+
1754
+ ### Deploy
1755
+
1756
+ **Records first, then control and the gateway, then the plugin and the console.**
1757
+ **No migration runs anywhere, and no schema version moves.** Control's
1758
+ migrations are the ones 0.9.12 shipped and its schema is unchanged. In the
1759
+ records service every table 0.10 adds is `create table if not exists` in the
1760
+ `ADDITIVE` block (`records/src/schema.js`), created when a space file is opened
1761
+ without raising its `schema_version`, so an older records service opens the
1762
+ same file and ignores the tables it does not know, and nothing is rewritten.
1763
+ Back up anyway, as for any deploy. In order, what is additive:
1764
+
1765
+ 1. `jobs`, `job_runs`, `job_versions`, `job_requests`, `job_consents`: a job,
1766
+ each run of it, every version it has had, the person's bind-like request and
1767
+ the version they confirmed.
1768
+ 2. `job_items`, `job_extracted`, `job_curation`, `job_withdrawals`: the items a
1769
+ run read, the items the extract engine has already sent to the model, the
1770
+ memories and graph entries a run proposed, and an item a later run withdrew.
1771
+ 3. `binding_resyncs`, `job_hosts`: a binding's one restart per UTC day, and the
1772
+ host a binding runs on.
1773
+ 4. `job_lens`, `job_logs`: the block a job last wrote, by its own content hash,
1774
+ and its run log.
1775
+ 5. `act_grants`: one row per verified-caller grant spent, keyed by the host and
1776
+ the grant's single-use id, written in the same transaction as the act, so a
1777
+ second use fails on the primary key. It holds no content: the act's answer is
1778
+ the receipt.
1779
+ 6. `plugins`, `plugin_digests`: each plugin declaration as the person's
1780
+ collector reported it and this service validated it, with its package,
1781
+ source, version, digest and state; and the first digest seen for each package
1782
+ install at one version, so a different digest at the same version is an
1783
+ edited install.
1784
+ 7. `plugin_requests`, `plugin_consents`, `plugin_pending`, `plugin_changes`: a
1785
+ plugin-declared source's request and the account the person's collector
1786
+ probed, the consent they confirmed in a browser session, and the changes that
1787
+ wait for them and the ones applied.
1788
+
1789
+ - **Jobs are on by default** (`RECORDS_JOBS=on`), and a job stores what it reads
1790
+ and writes its page under its own grants. **`RECORDS_JOBS_EXTRACT` is off by
1791
+ default**: with it off, a job collects, renders its page and records its runs,
1792
+ and the extract stage proposes nothing, so no memory, commitment or graph
1793
+ entry comes from a job. Turn it on only after the extract eval passes on the
1794
+ cell's own model. `RECORDS_JOBS_DAILY_TOKENS` and
1795
+ `RECORDS_JOBS_EXTRACT_TOKENS` bound the spend.
1796
+ - **The routines are unchanged**: their scheduler, their budgets and their
1797
+ propose-only default (`RECORDS_ROUTINE_APPLY=propose`). Jobs and routines keep
1798
+ separate budgets and breakers in this release (shared in 0.11).
1799
+ - **`mem_spaces jobs` `archive` and `resume` now need the person's proof**: a
1800
+ console session, or the `state_digest` a preview showed (`mem_spaces jobs get`
1801
+ names it). An agent's call carries it; a bare bearer's is refused. This is the
1802
+ job's archive, not `mem_spaces archive`, which archives the space itself.
1803
+
1804
+ That is all 20: the job ledger's 13, `act_grants`, and the 6 `plugin*` tables.
1805
+
1806
+ ### Known issues
1807
+
1808
+ - **Jobs and Routines keep separate budgets and breakers; shared in 0.11**
1809
+ (`extract` is off by default).
1810
+
1811
+ ## [0.9.14] - 2026-11-13
1812
+
1813
+ This release includes 0.9.13. **0.9.13 was not released:** its gate found one
1814
+ harmful answer (H2, `hand-nonmember-memory`), so its changes ship here with the
1815
+ fixes below, and its Deploy and Known issues sections are kept here too.
1816
+
1817
+ ### Security
1818
+
1819
+ - **An agent or API key could replace a team page's lines, or retire the page, through a proposal; refused now.** A bearer (an agent token, or an API key with editor rights in a space) could propose a change to an existing page with `records.put` and accept it with `review.decide`; `/records/v1/<method>` serves both calls as editor writes, so no ask was raised. Accepting rewrote the target page directly (`records/src/store.js`, `#apply`), which never ran the team-page check a direct `records.put` runs: the page's body was replaced, and with `decision: "edit"` its title too. The same accept could carry a `supersedes` naming a team page, and `#supersede` had no team-page check either, so a page was retired that way — from a direct put, an accepted create proposal and an accepted merge proposal; a bearer's `records.revise` retire is refused (`page_lines_kept`, FIX-0911/FIX-0912), and that got round the refusal. Both routes now run the checks a direct write runs: on a page in a shared space a bearer's accept only inserts lines and keeps its title and type, the contest branch (a lifecycle change a bearer's `records.revise` already refuses) is refused, and a bearer never supersedes or retires a page in a team space. An `append` proposal is the append it proposes: its line may not hold an HTML comment or tag, a code fence, a heading or a setext underline, or start with a space, exactly as a direct `records.append` on a team page (a fence or heading was accepted before). A person's accept in Memory's console (a browser session) is unaffected, and so is a bearer in a personal space; a merge of records that are not pages still applies. No agent-facing text changed.
1820
+ - **Behaviour change: accepting a team-page proposal that changes lines now refuses for an agent, even after the person approves the `mem_spaces` ask.** The gateway's approval is a prompt on the agent's call; it sends no `x-records-credential`, so the records service still sees a bearer, and a bearer never rewrites a team page's lines. `mem_spaces` `review` `decide` still asks in a shared space, and every other proposal (an `append`, a create, a memory, a personal page) is decided there as before; for one that would change a team page's lines the answer is `page_lines_kept`, and the person accepts it in Memory's console, where a browser session applies it.
1821
+ ### Fixed
1822
+
1823
+ - **A hit never answers a question no record answers, and a stated rule or date still does** (the 0.9.13 gate's H2, in `hand-nonmember-memory`; reworded after the candidate's review). Asked "is Ama planning to leave the payments team?", with no record saying so, the agent answered `"Partly — but not a stated plan… 'Written by [[people/ama]] before her leave'"`: a partial yes read out of a page whose "leave" was a leave of absence. The item expects abstention, `{"value":null}`. Protocol rule 2 keeps the ban — a rule, date, decision, exception or fact is recorded only if a tool returned it this session, and an invented rule never justifies a denial — and adds the narrow part: "If no record states it, say so." It is 1,441 characters of its 1,450, six fewer than 0.9.13's: the ban is said in fewer words ("Never call … recorded" for "Never present … as recorded"), and no other rule lost a word to pay for the clause. `mem_recall`'s block, when it returns hits, opens with the detail, because a tool result costs nothing per model step: "Only what a hit states is recorded: if none states the asked fact, say it is not recorded, never partly, and never infer it from a hit on another topic; applying a stated rule or date is fine." That last clause is what the review changed: a first draft said "never partly or by inference" in both places, which risked abstaining where a recorded freeze or constraint does answer the question (`core-temporal-inside`, `core-temporal-outside`, `core-constraint-allow-*`, `x-time-freeze-before-release`). No answer format is named in the product: the JSON shape stays in the eval item's prompt, and `test/recall.test.js` fails if the block names one.
1824
+ - **GitHub collection keeps working with opencode-github's next release, which checks each GitHub API read; Memory grants exactly the four reads the collector makes.** The published `v0.0.0` gated only writes, so the collector's session (`* * deny`, plus `github_events_list` and `github_get_me`) collected GitHub with no API read grant. The release after it asserts `github_api` on each inner GET of `events_list` unattended, so Memory's own deny refused `GET /user` with `PERMISSION_DENIED` before any request was sent and nothing was collected. The registry now declares `apiReads` for github (`src/sources.js`), and `sourceAllowRules` grants `github_api` on exactly `GET /user`, `GET /search/issues`, `GET /search/commits` and `GET /notifications`, the four reads `listEvents` makes. Not `GET *`: Memory's rules are exact grants, so a plugin that starts reading another path fails loudly as a collector error, never silently, and a declared API read on a wildcard resource is refused when the rules are built. A binding made before this release is brought up to the rules by its session's rules hash, so it needs no rebind. `test/github-collect-grants.test.js` holds the session to those six grants and every other `github_api` read to `deny`, and `test/source-reads.test.js` pins every source's rules exactly, so another source's cannot change unnoticed.
1825
+ - **No test process reads or writes the developer's own user-level home any more** (the 0.9.10 known issue "some tests read the real user config"). `test/support/tmp-isolation.js`, preloaded into every test process by `npm test` and its siblings, now sets `XDG_CONFIG_HOME` and `XDG_STATE_HOME` inside the temporary root it already made, overriding whatever the caller's shell names. Before, a test that did not set `XDG_CONFIG_HOME` fell back to `~/.config/opencode/`, so a `skipAsks` in the machine's own config changed the result: with `skipAsks: memory.forget` there, `test/permissions.test.js`'s "the plugin registers the rule at setup" saw `allow` where it expects `ask`. Reproduced by pointing `HOME` at a temporary directory with such a config (never the real file), and green with the same `HOME` afterwards. `test/user-config-isolation.test.js` holds the setup to it: the config root is inside the temporary root and never `~/.config`, an inherited `XDG_CONFIG_HOME` is overridden, and a config written in the temporary root is still read, so a miss stays a miss and not a blindfold.
1826
+ - **A placement move that loses to a purge says so** (#23). The move's two 404s now name which is missing, `space_not_found` or `placement_not_found` (they were the generic `not_found`), so an operator or a test can tell "no such space" from "the space is here but its placement was purged". The intermittent `200/400` in the PostgreSQL suite was not a status-code bug in the losing move: it was `data_verification_required`, the attestation guard deciding inside the move's transaction on a move that took the space row first, so the purge it was racing then saw an unchanged placement and went ahead (ab7e5173 added the attestation to the racing test, which is why CI went quiet). `control/test/lifecycle-hardening.test.js` now pins the losing move, with and without an attestation, at `404 placement_not_found`; the PostgreSQL race test pins the same code on its `200/404` outcome and names both codes in its failure message. The race passed 10 runs in a row on PostgreSQL 16.
1827
+ - **A correction to the 0.9.8 note about `RECORDS_FORGET_SECRET`.** The 0.9.8 Deploy step said the records service "stops at start without it". It does not: an unset `RECORDS_FORGET_SECRET` is allowed and the service starts, keeping a random per-space text key in the space file's `meta` table (`records/src/config.js`, `forgetSecret`; `records/src/store.js`, `#forgetTextKey`). Only a secret that is *set* and shorter than 32 bytes throws, at startup. What the 0.9.8 step meant, and what stands: a production cell must set it, because a space that holds purge entries made under the secret refuses `forgotten.match` with `503 forget_secret_missing` once it is unset, and setting it keeps that key out of the space file. The 0.9.8 step now says that; its instruction to set the secret is unchanged.
1828
+ - **An overdue commitment's Inbox notice stays category `commitment`** (#48), not the `alert` the issue first proposed. Jelly's own inbox names `alert` "Security alerts", reserved for account and device security that breaks through the person's Pause, and "Commitments" for the rest; an overdue reminder is neither, and the item's key already says `commitment:<id>`, so the category agrees with what the host routes. Nothing in Jelly's expectations for the notice (one item per commitment, updated in place each day, cleared by a closing or a new due date) changes with it. The declared enum is pinned as a literal in `test/views-overdue.test.js`, beside the constant.
1829
+
1830
+ ### Added
1831
+
1832
+ - **Jelly's display-only declarations for the designed Memory pages** (#55, the split's first part). `capture` declares `default: true`, so a host draws the plugin's own default instead of "Capture is off"; `contributes.workKinds` labels every declared tool, once, in a conversation (its labels and icons; 0.9.13's #57 regrouped these into recall, remember and organise); `inbox.list` items carry `kind` so a host routes one without reading its key's prefix (0.9.13's #57 made it the proposal's own type, with `commitment` for an overdue commitment); a `review.list` row carries `payload {kind, type}` when accepting it would make a record; and a `memory.forget` ask carries `space_id` and `space_name`, as `page.write` and `wiki.write` already did, so an approval reads "… to Platform". All additive and display only: no gate, no read, no act. The acts and the new reads stay in the CRUD slices (S1 to S7) that need verified grants.
1833
+ - **A short instruction file for hosts that put Memory's protocol in every agent's `instructions`** (#50). `docs/agent-instructions.md` is the rules only: the 9 rules the always-on block is built from, one more that only a static file can carry (what to do when a tool says memory is unavailable), one line on where a thing goes and one on what an answer means. 1,948 characters, no tool map, because the engine's catalogue already shows every argument. `jelly.instructions` names it, so a host need not pin a path, and the file names `mem_recall`, so `hasProtocol` still sends no second copy. `npm run gen:protocol` writes it beside the protocol's blocks, and `test/protocol.test.js` holds the two equal and the file under 2,000 characters.
1834
+ - **Receipts for a remembered write** (#57). `mem_remember`, `mem_commitments` add
1835
+ and `mem_revise` answer with `metadata.memoryReceipt`: what was stored, where,
1836
+ and the record's id, so a host draws the write it made. The remembered view
1837
+ (`views/remembered.html`) reads it, and a remembered tool-result view renders
1838
+ one write.
1839
+ - **A proposal's own kind on an Inbox item** (#57). An item's `kind` is the
1840
+ proposal's type (`create`, `team_write`, `share`, …) where it has one, and
1841
+ `commitment` for an overdue commitment, so Jelly's `kind?` takes it.
1842
+ - **A memory row says who wrote it, where, and its version** (#57).
1843
+ `memories.recent` rows carry `agent`, `task`, `version` and `copies`, and the
1844
+ read takes `agent` and `task` filters.
1845
+ - **`pages.list` counts backlinks** (#57): each row carries `backlinks` (at most
1846
+ 20, one `records.backlinks` read per row asking for 21) and `backlinksMore`
1847
+ when a page has more, and the read takes a `type` filter.
1848
+ - **`terms.list`** (#57): the people, projects, teams and glossary terms Memory
1849
+ knows, with their record counts, so a host can offer them as suggestions.
1850
+ - **The meeting page type** (#57): `records` and the console take `meeting` as a
1851
+ page type beside person, project, team, topic, runbook, decision, glossary,
1852
+ journal and index.
1853
+ - **Work kinds for the agent-facing tools** (#57): `contributes.workKinds`
1854
+ labels every declared tool exactly once (recall, remember, organise), so a
1855
+ conversation shows Memory's own label and icon for each call. This replaces
1856
+ #55's per-call list, whose five labels left most tools unnamed.
1857
+ - **`npm run check:jelly:master`** (#57): `scripts/check-jelly-master.sh` runs
1858
+ the declaration's samples against Jelly's own `origin/master` Inbox and view
1859
+ readers in a temporary clone. It never writes the Jelly repository, and it
1860
+ shows when a field Jelly refuses can be turned on.
1861
+ - **The fields Jelly needs on reads it already uses** (#58 C). View reads only:
1862
+ no agent-facing text, no new method, no act.
1863
+ `pages.read` and each `pages.list` row carry the page's **owner**
1864
+ (`{id, name}`): the record's own `owner`, named by the space's member roster
1865
+ (control's `listMembers`, read once per view call with the caller's token and
1866
+ never kept between calls). It is `name`, not the issue's `label`, because
1867
+ Jelly's `readPage` reads `owner.name`. **A person Memory can name, or no owner
1868
+ at all:** an id is not a name, so the field is left out when the roster cannot
1869
+ name that person — the usual answer for a reader holding only a page grant,
1870
+ since control's member list needs the viewer role — and always for the routines'
1871
+ own user (`routines`), which owns what a routine writes and is not a person. `pages.read` also carries **`reviewed`**
1872
+ and **`reviewDue`** from the page's own metadata (`fields.reviewed`,
1873
+ `fields.review_due`), and says nothing when the page names none: Memory keeps no
1874
+ review schedule of its own. `reviewDue` is a boolean, not the issue's date,
1875
+ because Jelly draws "Review due" from `reviewDue === true` and reads a date as
1876
+ "not due".
1877
+ - **`pages.list` pages on** (#58 F2): a `cursor` input, and a `cursor` and `more`
1878
+ in the answer, for a folder with more than 150 pages. The token is the records
1879
+ service's own. Rows are sorted by title within one page only, a page edited
1880
+ mid-walk can be skipped but never listed twice, and a listing cut for size still
1881
+ pages on: the rows kept are a run from the top of the service's order, so one
1882
+ more read for exactly those asks for the cursor that continues after them
1883
+ (`docs/jelly.md`).
1884
+ - **`review.list` rows say what a held write is tied to** (#58 F4): `session` and
1885
+ `turn` (recorded at hold time; `src/tools/held-write.js` now records the turn as
1886
+ well as the session), `held` (`true` for a write Memory holds for approval), and
1887
+ `space {id, name}` (the shared space it would be saved in, recorded at hold
1888
+ time). Jelly's `readReview` ignores what it does not know, so these ride on the
1889
+ declared row.
1890
+ - **`graph.links` takes a `folder`** (#58 F7): every page in a folder and the
1891
+ links between them, in one `records.list` read instead of up to twelve
1892
+ neighbourhoods. Only the folder's own pages are nodes; a link that leaves it is
1893
+ not drawn, because its target's title is not in the read.
1894
+ - **`memory.overview` carries `spool {depth, oldest}`** (#58 F6): how many
1895
+ captures still wait to be sent, and when the oldest was queued, from the engine's
1896
+ own queue (`spoolStats`, the figure `mem_status` shows). It is that machine's
1897
+ queue, not the speaker's, so it says only a count and a time, and nothing on a
1898
+ memory that cannot be used.
1899
+
1900
+ ### Notes
1901
+
1902
+ - **Not added, with the reason.** `profile.read` gained no `page` (#58 F5): the
1903
+ persona and scenarios are core documents, not records, and Memory names no page
1904
+ for either, so every row would carry `null` and teach a host to draw a dead
1905
+ link. `graph.links` gained no `community` (#58 F7): a community is a clustering
1906
+ of the graph, not a property Memory keeps, and a cheap guess would mislabel a
1907
+ person's pages.
1908
+ - **#58 F8, for the record:** yes, sharing a conversation's space keeps the chat
1909
+ space (commit `8ce7329`, "an explicit space applies to that call only; the
1910
+ session is not sent with it"). The first release to contain it is **0.8.4**
1911
+ (`git tag --contains 8ce7329` starts there; 0.9.5 has it too).
1912
+
1913
+ ### Deploy
1914
+
1915
+ **Records first, then control and the gateway, then the plugin and the console.**
1916
+ The records service carries 0.9.14's security fix (an accepted proposal no
1917
+ longer replaces a team page's lines), so it must be the first thing upgraded.
1918
+ A meeting's page type (`records/src/model.js`, `meeting`) is new to the records
1919
+ service in this release; records 0.9.12 refuses it with `invalid_type`. Until
1920
+ records 0.9.14 is live, `pageTypeFor` (`src/tools/records-kit.js`) and the
1921
+ console's `meetings/…` pages name `meeting`, so a write to one fails. Self-hosters
1922
+ who run a separate records service must upgrade it first; a single cell's
1923
+ rollout already orders it so.
1924
+
1925
+ ### Known issues
1926
+
1927
+ - **An Inbox item's `session` is deferred** (#57). A held team write records the
1928
+ session it was made in (`source.session`) and `inbox.list` reads it, but
1929
+ Jelly's strict item reader has no `session?`, and a field it does not know
1930
+ makes it refuse the whole Inbox. It stays off the wire behind
1931
+ `INBOX_ITEM_SESSION` (`src/views/contracts.js`) until Jelly's schema accepts
1932
+ it; `check:jelly:master` shows when that is.
1933
+
6
1934
  ## [0.9.12] - 2026-11-12
7
1935
 
8
1936
  This release includes 0.9.11 and the unreleased versions before it (0.9.6 to 0.9.10). Their sections below list what they changed, their known issues still apply, and the Deploy list under 0.9.8 applies to this release, together with the Deploy steps below.
@@ -371,6 +2299,8 @@ From the 0.9.9 release gate's adjudications (`gate099/ADJUDICATION-A.md`,
371
2299
  - **Some tests read the real user config.** Tests that do not set
372
2300
  `XDG_CONFIG_HOME` read the developer's own user-level OpenCode config, so a
373
2301
  `skipAsks` there can change their result. Run them with a clean config.
2302
+ (Fixed in 0.9.13: the shared test setup points the user-level homes at each
2303
+ process's temporary root.)
374
2304
 
375
2305
  ## [0.9.9] - not released
376
2306
 
@@ -903,8 +2833,10 @@ has to remove text first.
903
2833
 
904
2834
  1. **Back up Cloud SQL.**
905
2835
  2. **Merge and apply deploy PR #33, then add the forget secret's version.**
906
- `RECORDS_FORGET_SECRET` is required (at least 32 bytes; the records service
907
- stops at start without it) and must be applied **with or before** 0.9.12.
2836
+ `RECORDS_FORGET_SECRET` must be set in production, at least 32 bytes, and
2837
+ applied **with or before** 0.9.12. A *set* secret shorter than 32 bytes
2838
+ stops the records service at start; unset, it starts and keeps a per-space
2839
+ key inside the space file (see the 0.9.13 correction above).
908
2840
  3. **Merge deploy PR #32 and confirm the OS Login operator name.** Set
909
2841
  `CONTROL_ADMIN_OPERATORS` to map each person's `x-operator` name to their
910
2842
  control user, for example `jane_doe_example_com=jane.doe@example.com`