Monet

Store durable knowledge. Similar evidence normally attaches to an existing concept; novel, incoherent, species-mismatched, or stage-mismatched evidence creates a concept. Evidence that matches several concepts equally is REFUSED rather than guessed: the error names the candidates, and you re-send with `attachTo` or `resolution="forceNew"`. The acknowledgement returns `circle`, `action`, and `conceptId`; anomalous forks also return `resolutionMode` and `score`, flagged pairs add `nearMatchId`/`nearMatchScore`, and correction/rule outcomes add `contradiction`, `ruleSuccession`, or `extractionCandidate` only when present, and a store into an archived circle adds `guidance` naming what recall will not reach. Use `attachTo` only when identity is known, or `resolution="forceNew"` for known-distinct items. Use kind="correction" to challenge prior memory. Use kind="rule" with `rule`; stored rules are advisory because blocking severity is declaration-only in memory_declare. Synthesis happens later on explicit read.

Declare a user-authorized rule, stage, principle, or preference, or withdraw a declared rule. Never call on agent initiative. This is the only tool that may create blocking rules, replace a rule binding, or end a declaration. A stage is a named moment; rules bind content to stages. Principles and preferences enter the always-on skeleton without stage or severity; mechanical concerns return as non-blocking `advisories`. Skeleton changes include `instruction` only when a registered standing surface became stale. A permissive standing grant is a rule, not another species. `withdraw` retires a declared rule so no stage delivers it; a rule whose deny is still live must be declared advisory first, and one carrying an open question is refused until the question is answered. memory_restore brings a withdrawn rule back.

Record a human verdict on a principle or preference candidate after conversational review against the skeleton battery (Generates/Covers/Transfers/Exits). Approve/re-ratify enters the candidate in the skeleton and can link generated rules; reject keeps it out; retire ends current membership. The latest verdict governs membership, while every verdict remains in history. `packet` preserves exactly what the human saw. Name `entrance` so the record can later say whether anything gated this entry: "extraction" requires `battery` (all four gates answered), "declaration" forbids it because sovereignty replaced the test. Membership changes include `instruction` only when a registered standing surface became stale.

Find memories by similarity. Returns ranked pointer cards, not content; call memory_fetch with a card's id and non-default circle to read it. Omit circle for store-wide search. Empty results mean no match.

Read-only curation workbench for one circle: compact counts, livingModel cards, bounded queues for possibleDuplicates, extractionCandidates, openContradictions and gate exceptions, plus the ratified skeleton. A skeleton member's `homeCircle` names the circle it is homed in and appears only when that is not the circle you asked from; its absence means the member is homed here, and memory_ratify only accepts a candidate homed in the circle you pass. Opt into dirty or stale worklists; truncation fields report omissions. It never returns bodies: memory_fetch an id, use memory_resolve for contradictions or pair flags, and memory_detach with destConceptId to consolidate a duplicate. Pass entity to list one hub's memories.

List one circle's memories as structural cards, never bodies; use memory_fetch to read one. Returns up to `limit` plus `nextCursor`; pass that as `cursor` until absent. Keyset pagination stays valid while earlier pages are reassigned. Use `withProvenance` to group memories by evidence paths, then memory_reassign_circle to migrate them.

Read a concept by id. Normal concepts return `body` and `observationCount`; evidence appears only with observations:true as newest-first pages. If `needsSynthesis:true`, pull every page, reconcile one body, then call memory_synthesize. `bodyTruncated` means recover from observations. A disputed concept adds `status` and `openContradictions`; mediate with memory_resolve({ contradictionId: openContradictions[i].id }).

Record that you asked the user whether an action followed the rule it read. Call this when you put the question, before their reply. The momentId is the one `stage_lookup` returned when it handed you that rule; a later `stage_lookup` also names earlier moments with no question put — candidates, not debts, because the record does not say whether an action followed any of them. Ask where one did.

Record whether the action followed the rules read at that moment: 'followed' or 'not-followed'. No question is put first — record your own reading. FIRST WRITE WINS: the same answer again is accepted, a differing one is refused, so a later correction does not land here — when a rule turns out not to have been followed, the destination is that rule's own record. This says the action followed the rule; it never says the rule caused it.

At a stage named by agent_context, fetch its rules before acting. A hit returns bounded rules with reasons and omission recovery fields. `homeCircle` names the circle a rule is homed in, and appears only when that is not the circle you asked from; its absence means the rule is homed here. `parentDisputed:true` means `disputedParentIds` should be memory_fetched; projectedFromPrincipleId is only the display parent. A miss returns the live stage index.

Store one coherent body synthesized from all of a concept's observations. Clears `needsSynthesis` and records a revision.

Track work and capture finds as they happen — nothing is owed at session end. When a work directive lands, open the plan: work-level items that may outlive the session (fine-grained decomposition stays in the host's own todo). When something surfaces that is not this work, `inbox` it — one line, keep moving. Before reporting completion, settle: close what resolved, and dispose the inbox with the user — do it now, `filed` with a `ref`, `dropped`, or leave open to keep. This MERGES: `open` adds, `close` resolves by id, anything unnamed stays untouched. Address a workstream by `title` (mints if new) or `id` (exact); with neither, the one this session already touched, or the only active one — several active means refusal with the list. The receipt is only what this call did: `opened`/`closed` item ids, `status` only when this call changed it, `notClosed` only when a `close` id is not in the addressed list (it did not close; an inbox item closes under `id: "inbox"`), and — only when the checkpoint landed in an archived circle — `guidance` naming that circle.

Two reads, two moments. Resume — on continuation intent only, never a fresh directive: omit `id` to list active/paused workstreams and confirm which to resume; then pass its `id` for detail — OPEN items only, questions first, each carrying the id `close` takes. Settle — `id: "inbox"` before reporting completion: every find awaiting disposition, this session's and every kept one. `closedCount` says how many resolved items exist without delivering them; `includeClosed` returns them with `state`, `closedAt`, and `ref` for the filed. Advance `detailOffset` by items actually returned; `detailOmitted` is the true remainder.

Open a contradiction when stored memory conflicts with newer evidence. The concept becomes disputed until memory_resolve mediates it. Prefer memory_store kind="correction" when also storing the correcting evidence.

Mediate a contradiction or dismiss a flagged pair. CONTRADICTION: pass contradictionId, decision, and a reconciled body for accept-new/keep-current. accept-new keeps the correction; keep-current retires it; dismiss records no conflict. Name contradictedObservationId (a live, older, same-concept observation): on accept-new it is superseded exactly; on keep-current it is recorded as the kept prior while the correction is retired either way. Without it, accept-new supersedes only a sole older live observation; if several exist, none is retired and body is required. PAIR-FLAG DISMISSAL: pass conceptAId + conceptBId only. One dismissal clears both possible-duplicate and extraction-candidate flags between the pair; if only one relation is wrong, correct or detach instead. rowsUpdated:0 is an idempotent no-op.

Move observations out of a concept to undo a wrong merge. By default they form a new concept; destConceptId attaches them to an existing same-circle concept. The source is recomputed and marked for synthesis. Moving all observations into a destination deletes the source, consolidating a duplicate. Without a destination, at least one observation must remain; use memory_reassign_circle to move a whole concept across circles.

Move a concept, its observations, and graph membership to another circle. Pass exactly one of id or ids; batches are per-item atomic and report errors without aborting. `circle` is the current home. `auto` merges a destination match; `forceNew` keeps it distinct and flags a near match as possible_duplicate. Use this to home legacy default memory in its project circle.

Hide a memory: it leaves memory_search, memory_fetch, memory_list and the overview counts, its evidence untouched, and memory_restore brings it back — its graph re-derived from that evidence rather than replayed, so ordering and reinforcement history do not survive the round trip. Pass exactly one of id or ids; batches are per-item and report errors without aborting. `circle` is the concept's home. A memory leaves with the authority it entered on, so this refuses one that entered by declaration or by ratification, and one carrying an open contradiction or an undismissed duplicate/extraction pair flag — retiring those would end the question by making its subject vanish instead of answering it. Each refusal names the tool that withdraws that authority first, or says plainly when no surface does. Ordinary memories, and rules an agent stored itself, retire freely.

Undo memory_retire: a retired memory is searchable, fetchable, listed and counted again, and its graph is re-derived. Pass exactly one of id or ids; batches are per-item and report errors without aborting. `circle` is the concept's home.

Manage project-locality circles. Rename preserves the old name as an alias. Merge moves all concepts; forceNew (default) keeps near matches distinct and flags them, while auto deduplicates. Archive hides a circle from store-wide recall/listing without deleting it; unarchive restores it. List includes archived circles. Use entities/edges, not circles, for topics.

Session-start orientation. Call first. Returns resolved `circle`; `resolvedFrom` marks an alias. `stageIndex` names moments whose rules require stage_lookup. Skeleton delivery has three states: no mirror fields means loaded standing files are current; `mirrorStale` + `instruction` requires user-confirmed reconciliation; `skeleton` contains members not covered by a standing file. A member's `homeCircle` names the circle it is homed in and appears only when that is not the circle you asked from; its absence means the member is homed here. `open` counts workstreams and inbox items still open — mention them to the user; resume only when asked.