chore: record the command-split sign-off, the question-gate fixes and new drafts

.abcd/config/reading-presets.json

@@ -60,10 +60,10 @@
         "test"
       ],
       "window": {
-        "tokens_est": 1530000,
-        "measured_tokens_est": 1506408,
-        "measured_bytes": 5799671,
-        "measured_at": "2bb8b51d95cbf8cf93b784bfc8d9f6a62b496075"
+        "tokens_est": 1550000,
+        "measured_tokens_est": 1528764,
+        "measured_bytes": 5885743,
+        "measured_at": "364225261371a6e32b5f2907941ab552b95a2162"
       }
     },
     "entailment": {
@@ -132,10 +132,10 @@
         "intent-projection"
       ],
       "window": {
-        "tokens_est": 450000,
-        "measured_tokens_est": 440309,
-        "measured_bytes": 1695192,
-        "measured_at": "2bb8b51d95cbf8cf93b784bfc8d9f6a62b496075"
+        "tokens_est": 460000,
+        "measured_tokens_est": 450548,
+        "measured_bytes": 1734612,
+        "measured_at": "364225261371a6e32b5f2907941ab552b95a2162"
       }
     },
     "comparative": {
@@ -216,10 +216,10 @@
         "test"
       ],
       "window": {
-        "tokens_est": 1540000,
-        "measured_tokens_est": 1515443,
-        "measured_bytes": 5834459,
-        "measured_at": "2bb8b51d95cbf8cf93b784bfc8d9f6a62b496075"
+        "tokens_est": 1560000,
+        "measured_tokens_est": 1537800,
+        "measured_bytes": 5920531,
+        "measured_at": "364225261371a6e32b5f2907941ab552b95a2162"
       }
     }
   }

.abcd/development/brief/04-surfaces/README.md

@@ -390,6 +390,19 @@ that everything it reads is data, never instruction.
 `docs-currency-reviewer`, the reviewer the release gate runs as a semantic gate,
 is documented in [`10-docs.md`](10-docs.md).
 
+## Library and memory: two different jobs
+
+abcd keeps two kinds of remembered material, and they do different jobs. The **library** is evidence you consult; **memory** is know-how that finds you.
+
+| | Library (`/abcd:library`) | Memory (`/abcd:memory`) |
+|---|---|---|
+| What it holds | Outside material: papers, links, and the cited notes drawn from them | Short lessons learned while working, such as "this test is flaky under load" or "the person wants every question to carry an example" |
+| Who adds to it | The person, deliberately, saying whether each item is confidential or public (abcd asks when they did not say) | Mostly agents, in the middle of a session |
+| How it comes back | The person asks ("what do my sources say about pacing?") and gets answers that cite the item they came from | Brought into a session automatically when a prompt matches the words the note was saved with |
+| Where it can go | Into a decision as a cited source; a confidential item is never named in anything public | Into the project's record, when a note is promoted so that every agent receives it |
+
+A library answer can become a memory note ("source X says Y", with its citation), but the two are not one store with two names: the library is for what a decision may need to cite, and memory is for what an agent would otherwise relearn. The glossary entries [library](../glossary/core/library.md) and [memory note](../glossary/core/memory-note.md) define each term. The library merges what the sources, memory, consult and ingest pages hold today (itd-2610090831227812); memory notes are designed in itd-2610091918433290, and its open questions name where notes are stored and what an agent may write without the person's yes.
+
 ## Where to find related design
 
 - **Plumbing internals**: [`05-internals/`](../05-internals)

.abcd/development/brief/06-delivery/03-out-of-scope.md

@@ -144,7 +144,9 @@ gate. That is what keeps "not hand-counted" true after the day it was written.
 - `itd-2610071545380041` — Work about abcd itself goes to abcd as a report, never into a managed repository's own plans (draft)
 - `itd-2610091010348892` — abcdev.app shows the record of any public abcd-managed project, with abcd as the showcase (draft)
 - `itd-2610091016262335` — The product thinker and facilitator make a project's design decisions on abcdesign.app (draft)
-- `itd-2610090831227812` — A person's /abcd: list shows only the commands people use (draft)
+- `itd-2610091918433290` — Agents keep memory notes with /abcd:memory, recalled when they matter (draft)
+- `itd-2610100627454580` — An agent's text comes back from abcd's rewriter written for its reader and within its limits (draft; grows the question drafter)
+- `itd-2610100704270254` — An abcd run sets how many sub-agents it keeps alive by the models they run on (draft; builds on itd-2609201925079472)
 <!-- /index -->
 
 **Later-phase items with no intent id.** These four were written into the brief

.abcd/development/brief/glossary/README.md

@@ -79,8 +79,10 @@ glossary/
 │   ├── disembark.md
 │   ├── intent.md
 │   ├── ledger.md
+│   ├── library.md
 │   ├── lifeboat.md
 │   ├── loop.md
+│   ├── memory-note.md
 │   ├── milestone.md
 │   ├── oracle.md
 │   ├── persona.md
@@ -215,8 +217,10 @@ The complete write-back protocol is a **design target** of `/abcd:intent grill`'
 | [disembark](core/disembark.md) | stable | The act of packing a lifeboat — `abcd disembark pack <source-repo> <dest>` reads a source repository without writing to it and distils its settled artefacts, decisions, and configuration into a portable lifeboat directory at a destination outside that repository, which a fresh context can later unpack via `/abcd:embark`. |
 | [intent](core/intent.md) | stable | A press-release-shaped description of a feature written before implementation begins, capturing the user problem, proposed solution, and success criteria. |
 | [ledger](core/ledger.md) | stable | An append-or-move store a command writes and a human reads back, the issue ledger under .abcd/work/issues/ when the word stands bare; inside the cold-reading experiment the word means the warm material and its stores, which the read-block keeps from a reading (the ledger context's entries govern that sense). Four further ledgers share the word and are always named in full. |
+| [library](core/library.md) | draft | The person's collection of outside material (papers, links and the cited notes drawn from them), each item marked confidential or public when it is added, and consulted on request with every answer citing the item it came from. |
 | [lifeboat](core/lifeboat.md) | stable | A portable directory artefact packed by `/abcd:disembark` that captures the distilled knowledge and configuration of a source project so it can be unpacked into a fresh context by `/abcd:embark`. It always lands outside the source repository, at an operator-chosen destination. |
 | [loop](core/loop.md) | draft | The record loop — brief to intent to spec to shipped work to audited verdict and back onto the brief — which shipping closes twice, once by grading the acceptance criteria and once by rewriting the brief passage. Two other loops carry the word and are always qualified: the autonomous-run loop and the lifeboat round-trip. |
+| [memory-note](core/memory-note.md) | draft | A short lesson an agent learned while working (a fact about the project, the person or the machine), kept with the words that should recall it and brought back into a session automatically when a prompt matches; kept on the person's machine until promoted into the project's record. |
 | [milestone](core/milestone.md) | superseded | A planned end condition for a stretch of work; retired: the checkpoint is the derived release plus each intent's acceptance criteria. |
 | [oracle](core/oracle.md) | stable | An AI model invoked to review, reason over, or validate a project's artefacts — host-delegated by default, or reached through an opt-in oracle adapter. |
 | [persona](core/persona.md) | stable | A placeholder stakeholder character drawn from the abcd personas registry, used in press releases, intents, and design documents to represent a real user archetype without using real names. |

.abcd/development/brief/glossary/core/library.md

@@ -0,0 +1,36 @@
+---
+term: library
+bounded_context: core
+definition: The person's collection of outside material (papers, links and the cited notes drawn from them), each item marked confidential or public when it is added, and consulted on request with every answer citing the item it came from.
+aliases: []
+forbidden_synonyms: ["corpus", "knowledge base"]
+status: draft
+introduced_in: itd-2610090831227812
+starts_when: null
+ends_when: null
+not_to_be_confused_with: [core/memory-note, core/record-families]
+versions: null
+---
+<!-- Adapted from mattpocock/skills (MIT). See README Acknowledgements. -->
+
+# library
+
+The **library** is evidence you consult. You add a paper or a link with `/abcd:library add`, and abcd asks whether it is confidential or public when you did not say. Later you ask it a question, "what do my sources say about pacing?", and every answer cites the item it came from. A confidential item can inform a decision but is never named in anything public.
+
+## When to use
+
+For material that comes from outside the project and that a decision may need to cite: a paper, a standard, a vendor's documentation, a page someone sent you.
+
+## When NOT to use
+
+For what an agent learned while working ("this test is flaky under load"): that is a [memory note](memory-note.md). For the project's own decisions: those are records (an ADR, an intent, the decision log).
+
+## Examples
+
+- You add a research paper as confidential; an intent's prior-art section can rest on it, and no public page names it.
+- You ask the library what it holds on rate limits, and get three cited passages.
+
+## Related terms
+
+- [memory note](memory-note.md): know-how that finds you, where the library is evidence you consult
+- [record families](record-families.md): the project's own records, which a library item may inform but never replaces

.abcd/development/brief/glossary/core/memory-note.md

@@ -0,0 +1,36 @@
+---
+term: memory-note
+bounded_context: core
+definition: A short lesson an agent learned while working (a fact about the project, the person or the machine), kept with the words that should recall it and brought back into a session automatically when a prompt matches; kept on the person's machine until promoted into the project's record.
+aliases: ["memory"]
+forbidden_synonyms: []
+status: draft
+introduced_in: itd-2610091918433290
+starts_when: null
+ends_when: null
+not_to_be_confused_with: [core/library, core/record-families]
+versions: null
+---
+<!-- Adapted from mattpocock/skills (MIT). See README Acknowledgements. -->
+
+# memory note
+
+A **memory note** is know-how that finds you. An agent writes one with `/abcd:memory add` when it learns something worth keeping ("the person wants every question to carry an example"), together with the words that should bring it back. The same loader that brings in the project's rules brings the note back when a prompt matches those words, so no one has to remember to look it up. A note stays on the person's machine until it is promoted into the project's record, where every agent receives it.
+
+## When to use
+
+For a lesson an agent would otherwise relearn: a preference of the person's, a quirk of the machine, a trap in the project's tooling.
+
+## When NOT to use
+
+For outside material a decision may need to cite: that belongs in the [library](library.md). For a rule every agent in the project must follow: promote the note, so it becomes part of the record.
+
+## Examples
+
+- An agent notes that a test fails under heavy load and should be retried, recalled whenever a prompt mentions that test.
+- A note that has been recalled in several sessions is promoted into the project's rules, so a second contributor's agent receives it too.
+
+## Related terms
+
+- [library](library.md): evidence you consult, where a memory note is know-how that finds you
+- [record](record.md): where a promoted note ends up

.abcd/development/decisions/adrs/2610091918443997-what-may-enter-abcd-s-memory-notes-without-the-person-s-yes.md

@@ -0,0 +1,35 @@
+---
+id: adr-2610091918443997
+slug: what-may-enter-abcd-s-memory-notes-without-the-person-s-yes
+status: proposed
+date: 2026-10-09
+supersedes: null
+superseded_by: null
+related_intents: [itd-2610091918433290, itd-39, itd-3]
+related_rfcs: []
+related_adrs: []
+---
+
+# ADR-2610091918443997: What may enter abcd's memory notes without the person's yes, and how a note reaches the record
+
+## Context
+
+The product thinker asked on 2026-10-09 (itd-2610091918433290) for agents to keep memory notes through `/abcd:memory`, recalled by the rules loader. Notes are written mostly by agents, often mid-session, so what may be written without the person's yes is a trust question, and so is the step that moves a note from the person's machine into the project's committed record. Constraints already in force: abcd never touches the host's `~/.claude` (the product thinker's ruling of 2026-10-05); the memory-graduates-to-record principle (a lesson every agent should receive belongs in the committed record, never only one person's local memory); the private-names banlist and the scanner's redaction for anything committed; and the loader's ownership and size checks on the machine's rules file.
+
+Open before this record can be decided:
+
+- Which notes an agent may write on its own (for example a fact about the person's machine) and which need the person's yes (for example anything about another person, or anything promoted).
+- Whether promotion is the person's act alone, as the source ledger's flip is, or an agent's with disclosure.
+- What a note may never hold (secrets, private names, live network identifiers), and which check refuses it.
+
+## Decision
+
+_Not yet decided; settled at the planning interview of itd-2610091918433290._
+
+## Alternatives Considered
+
+_To be laid out at planning: an agent writes freely to the machine layer and promotion needs the person's yes; every write needs the person's yes; an agent writes and promotes, disclosed in the commit._
+
+## Consequences
+
+_To be written with the decision._

.abcd/development/intents/drafts/itd-2610091918433290-an-agent-working-in-an-abcd-managed-project-keeps-what-it.md

@@ -0,0 +1,51 @@
+---
+id: itd-2610091918433290
+slug: an-agent-working-in-an-abcd-managed-project-keeps-what-it
+spec_id: null
+kind: null
+suggested_kind: null
+reclassification_history: []
+builds_on: [itd-3]
+severity: minor
+origin: researcher-authored
+production_mode: hand-written
+related_intents: [itd-39, itd-36, itd-2610090831227812]
+related_adrs: [adr-2610091918443997]
+---
+
+# Agents keep memory notes with /abcd:memory, recalled when they matter
+
+## Press Release
+
+> An agent working in an abcd-managed project keeps what it learns as short memory notes that come back exactly when they matter: it adds, lists and removes them with /abcd:memory, each with the words that should recall it, and the same loader that brings in the project's rules brings a note back when a prompt matches. Notes stay on the person's own machine until one is promoted into the project's record for every agent to share, and abcd never edits the host's own memory files.
+
+## Why This Matters
+
+> _Why this matters to the user — replace before planning._
+
+## Mechanism
+
+> _Prompted (the claim-recording gradient): why the authors expect this to work, as a falsifiable "we expect X because Y" — not the outcome restated. Replace this line with the claim, or with the exact token `None stated.` alone on its line to record the claim as considered and declined._
+
+## Scope Conditions
+
+> _Required (the claim-recording gradient): the population, platform, scale, or assumptions this claim holds under, one per top-level bullet — `abcd intent plan` stamps each with a persistent identity. Replace this line with those bullets, or with the exact token `None stated.` alone on its line._
+
+## Acceptance Criteria
+
+- **Given** a person reading abcd's user-facing docs after this intent ships, **when** they look up memory, **then** the page explains memory and the library side by side in plain words (what each holds, who adds to it, how it comes back, where it can go), the same comparison the brief's surfaces overview carries, so the two are never mistaken for one store. (Required by the product thinker, 2026-10-09: "explain both in that accessible way in the docs and in the brief".)
+
+## Open Questions
+
+- Where notes are kept: a `memory.json` beside each `rules.json` layer (the machine's `~/.abcd.noindex/memory.json`, the project's `.abcd/memory.json`), read by the same loader, or entries inside `rules.json` itself. The facilitator's lean is `memory.json`: agents write notes, people curate rules, and the one-writer-per-file principle keeps an agent's note from editing the file that holds reviewed conventions; the product thinker confirms at planning.
+- What may enter a note without the person's yes, and how a note is promoted into the project's record: decided in adr-2610091918443997.
+- How this relates to itd-39 (memory pages recalled at the right moment): this intent writes and manages the notes; itd-39 retrieves pages. Keep both, bundle them, or let one refine the other.
+- What happens to the memory notes an agent already keeps in the host's own memory files, which abcd never touches: does abcd offer a way for the person to move a note across by hand?
+
+## Audit Notes
+
+_Empty. Populated by intent-auditor when intent moves to shipped/._
+
+## Decisions
+
+- 2026-10-09: the product thinker chose to manage memory notes through abcd's own rules loader rather than a separate recall path or the host's memory files (answer: "yes, file it as A"), after the verb-split interview freed the name `memory` by merging the sources and memory commands into `library`; `/abcd:memory` is an agent's command.