Glossary
Domain vocabulary — what each term means, where it is defined, and which words were deliberately ruled out.
This page is an index and an alias list, not a second set of definitions. Each term is defined on the page that owns its rules — this page says which page that is, so definitions never drift by being written twice.
It also records which words were ruled out, and why. That material otherwise lives only in plans, which are archived once the docs catch up — and archived plans are not maintained.
Agent skills that expect a CONTEXT.md domain glossary (e.g.
improve-codebase-architecture, grill-with-docs) should use this
page and the pages it links to. Do not create a parallel glossary
file.
Venue and placement
| Term | Meaning | Defined in |
|---|---|---|
| Venue | Where a folio item lands. There is one — the document (owner ruling 2026-08-25), and nothing declares it. | Permissions and Visibility → One venue |
| Document | The one venue: the instrument you read, edit and download. | Permissions and Visibility |
| Form | Not a venue. Only Goldie's agent-led posture survives under the name. | Permissions and Visibility → One venue |
| Export | A downloadable artifact, not a screen. One artifact — the document — in a Draft and a Final render. | Permissions and Visibility → Downloads |
| Outline | The collapse axis — headings-only view. How much of the document you are looking at, never what it is made of — that is the folio arrangement (ruled 2026-08-14). | Document Work Screen → Work Bar |
Two placement keys once stood in this section and neither is authorable:
display.targets and display.surfaces. display holds start_level and
numbering only. Their lineage, and why a replacement is an owner question
rather than a schema convenience, is at
The completed lineage.
A field is still authored once and read twice: its label is what the
person answering sees, its value interpolates into prose. That was never two
places — it is one namespace, and now one venue as well.
Roles and capabilities
| Term | Meaning | Defined in |
|---|---|---|
| Reader | Reads and comments. No write capability, no agent. | Permissions and Surfaces |
| Maker | Completes a document — holds write-data. The consumer role. | Permissions and Surfaces |
| Builder | Authors structure — holds write-structure. Sees module chrome. | Permissions and Surfaces |
write-data | Fill fields, answer the interview, correct values. | Permissions and Surfaces |
write-structure | Add / remove / reorder fields and blocks; classify, insert. | Permissions and Surfaces |
| Preview-as | Simulating a lower role. Downward only. | Permissions and Surfaces |
The crisp line: filling a field mutates document data; adding a field mutates document structure.
Content structure
| Term | Meaning | Defined in |
|---|---|---|
| Block | The universal leaf unit. Every block has a kind. | Folios Schema |
| Folio | The first-class, versioned authored-object family: Workspace, Project, Document, Module, content block and data block — the six kinds. Each Folio has stable identity, an immutable version chain, reuse posture and derivation lineage; a Field is deliberately excluded — it freezes with its data block version. Renamed from Content object 2026-08-09; "content" thereafter means content-block prose. On screen the implemented kinds share one shell (Stack) with one reading face (the About face was retired on 2026-09-10 by GB-221); the kind never implies geometry, and the concept — kind union, facet names — lives in packages/domain/src/folio rather than in the shell. On the canvas, a Folio is a Stack together with its Substacks — the whole assembly, and the only container that carries the family word (data-slot="folio"). | Codebase Architecture · Documents, Modules and Blocks → Workspace and Project · UI components → The Stack |
| Project | A Folio that contains Documents. Its Project Stack shows those Documents as Substacks, and it is the sharing grain: the Workspace is one person's home, the Project is what is shared. | The Workspace Is Home · Documents, Modules and Blocks → Workspace and Project |
| Workspace | The top folio tier — the container a person lands on, minted once for each person; its canvas is Home (the row below) and lists their Projects. The word belongs to this tier and nothing else (GB-260, 2026-09-14): the page chrome every canvas screen sits inside is the Canvas Shell (src/widgets/canvas-shell, CanvasShell), and the ground the paper sheets sit on is the paper surface (paperSurfaceClassName, which sets --color-chrome-light). Not machine-checked: the guard tests words, not meanings, and a ban on workspace would flag the tier's own WorkspaceFolio, WorkspaceIdentity and workspaceKey; the retired spellings (WorkspaceShell, paperWorkspaceClassName, the document-workspace class) are gone from src/, so this row is the record. | The Workspace Is Home |
| Active (Library) | A Library a Workspace or a Project draws on: ticked in the Libraries dialog on the Home card's menu (the Workspace) or a Project card's (that matter), and read by Goldie's search and the search card alike (owner, 2026-10-04, GB-347). Your own Libraries and ones shared with you are active by default everywhere; one you joined is active where you joined it; a saved list is exact. Code: librarySearchScopes, library/searchScope.ts. | |
| Home | The app's word for the person's Workspace screen (owner, 2026-10-04, GB-345): where sign-in lands, at /app, and what the sidebar's G opens. It is the Workspace's own canvas drawn on the container page under this name, not a page of its own: Projects first (one row in the person's kept order, its last cell a Show more card, since 2026-10-05; four and a Show all link before), the recent Documents, then one line naming their Libraries. The Folio kind stays workspace in schema and code; a second Workspace, should a premium account get one, grows a switcher on Home, never a new page. The separate Home page that drifted in beside it (src/pages/home) retired that day; its screen is kept as a deprecated story as reference for the marketing page. | The Workspace Is Home |
| Facet (retired) | A face of a folio — a card with two sides you switched between. Retired: a card has one face, and its About rows are a collapsible card at the top of the Control Panel conversation. No facet bar, no face tabs, no View selector. The word survives in code only as the two source strings a proposal diffs against (facets.content, facets.about). | Document Work Screen → The Control Panel |
| Stack | The one recursive furniture primitive every Folio kind is drawn with (settled 2026-08-13): Header? + Body + Footer? + Substack Portal?, with a hover-revealed drag handle hanging in the page margin beside each stack's top row, level with its gutter mark (ruling S, 2026-08-13) — one margin rail that drags the whole stack. Furniture vocabulary, not domain — nothing in packages/domain renames. The word was cleared for the primitive on 2026-08-13 (stack-panel-tray, ModuleWithBlocks, WORK_BAR_NARROW_WIDTH renames). | UI components → The Stack |
| Folio arrangement | Which folios exist, what contains what, and in what sequence — plus every structural change to it (move, insert, duplicate, remove, reorder at both tiers). Distinct from Folio (the family), from Order (the scalar encoding one position), from Stack (the furniture a folio is drawn with), and from Outline (the collapse axis). The optimistic local copy is the drafting editor's (model/folio-arrangement.ts); the persisted moves are convex/folio/arrangementWrites.ts. Named 2026-08-14 after a module called outline.ts collided with the collapse axis. | src/widgets/drafting-editor/model/folio-arrangement.ts |
| Folio insertion | A parent-owned arrangement operation that adds a child Folio: Document → Module, Module → Block, and, when implemented, Project → Document. The child kind still mints its own stable identity and initial version. | Documents, Modules and Blocks → Folio Insertion (Target) |
| Folio lifecycle | Operations on a Folio's own availability or reuse posture, such as Delete / Put back — reversible, on any Folio kind. Distinct from arrangement removal, which changes whether an assembled child belongs to its parent. | Documents, Modules and Blocks → Folio Lifecycle and Removal (Target) |
| Folio operation | A canonical action on a Folio or its arrangement. Its vocabulary drives names, grouping, capability, and destructive posture; menus project the available operations rather than restating them. | Documents, Modules and Blocks → Folio Operation Menus (Target) |
| Folio duplication | A source-owned copy-write branch, inserted by the parent arrangement immediately after its source unless a kind-specific rule says otherwise. | Documents, Modules and Blocks → Folio Duplication (Target) |
| Folio Library journey | Reuse-specific operations—promotion and insertion—that create or place standalone derivatives while preserving their own preconditions and data-safety rules. | Libraries |
| Folio reviewed edit | A proposed Folio change that follows the canonical Proposed Change lifecycle—propose, diff, revise, accept or reject, then apply. Its kind/facet adapter owns source grammar and validation; direct value writes are separate. | Documents, Modules and Blocks → Folio Reviewed Edits (Target) |
| Substack | A Stack rendered inside another Stack's Substack Portal. Relational, not structural — owner, verbatim: "A Substack is not a separate component type. It is simply a Stack in a nested relationship." A module's blocks are its Substacks; a Field is deliberately not one (it is Stack Body content). | UI components → The Stack |
| Substack Portal | The optional Stack region subordinate Stacks render through — the one nesting surface. Its own open input can gate rendering when a composition requires it, but Folio header disclosure does not: Document modules and Module blocks remain rendered while the parent's own face is closed. Containment is in the code, never the presentation: no indent, one left edge, white hairlines at rest. | UI components → The Stack · Document Work Screen |
kind | What a block's payload is: content (prose) or data (fields). It decides payload, spine and editor, and since 2026-08-25 carries no default venue. | Folios Schema |
| Field | One ordered declaration/value entry owned by a data block version. It has minted stable fld_ identity, editable handle, optional human-facing label, declared type and rules, and optional collected value. Fields fold into the containing module's data namespace; they are not standalone content objects. | Blocks Schema → Field entries |
| Module | A container for Blocks. In the UI, a Module Stack shows its Blocks in the Substack Portal. A Module is also a reuse, versioning, and namespace unit; it does not coincide with a section boundary. | Folios Schema · The Stack |
| Span | A heading and everything under it until the next heading of equal-or-higher level. Derived from block order, never stored. | Folios Schema |
| Callout | Guidance prose rendered to the reader in the document. The display.type: callout spelling is retired with display.type. | Folios Schema |
start_level | Where a block's outermost # sits in the six-slot scheme. Integer 1–4; optional, resolving block → module → document. Replaces display.level. | Numbering |
| Scheme | The document's six fixed level slots, each with label, glyph, compound, format. Level 2 is Section. | Folios Schema |
| Numbering flags | numbering: {headings, paragraphs, lists, resets} — whether an element kind participates in numbering, never in what style. resets is block-only. | Numbering |
| Projection | Numbering resolved at render time in two passes and never stored. | Numbering |
| Document data pool | Convention, not a module type: an ordinary module—usually handle data_pool—whose data blocks own facts shared for mixed use across the document. | Modules Schema → Data Pools |
| Block edit envelope | The single seam every block-editing mutation runs inside — owns load, guard, one-block match, and the editedAt stamp. | Block Edits Run Inside One Envelope |
| Block notification channel | The one path a block-scoped message takes to its block's notification row — refusals and confirmations both. Document-scoped actions toast instead, because they navigate. | One Block Notification Channel |
| Block refusal | A domain rule saying no to a block edit, thrown as structured ConvexError data carrying a refusal: true marker. Distinct from a fault, which is a broken invariant and stays a bare throw. | One Block Notification Channel |
order.position | A row's placement among its siblings: a gapped integer (1000/2000/3000) scoped to its parent — blocks by moduleVersionKey, modules by documentVersionKey. Ties break on the row's key. Not authored — derived from sequence position. | Flow → Ordering |
order.sibling_max | The highest position among a row's siblings at the moment it left the family. A bound, not a count; written only on promotion; advisory at restore. | Blocks → order.sibling_max |
flow.after | Retired. The old relative predecessor anchor. Historical rows may still carry it, but current reads and writes ignore it; ordering is order.position. | Flow → Retired after storage |
| Mention | An authored @ token that binds to a stable identity (fld_/blk_/… key) and survives renames. Anything addressable by stable identity can be mentioned — a Document, Module, Block, Field, or a Field's value. Retires "@ reference" in prose (settled 2026-08-09). | Stable IDs ADR |
| Resolved Mention | The contextual projection produced by resolving a Mention against the current document: target kind, current name and content. It is not stored separately from the Mention or its target. | Stable IDs ADR |
| Proposed Change | The canonical propose → tracked differences → revise → accept/reject → apply lifecycle. One baseline, one diff, one acceptance state, projected on both faces; "tracked changes" is its visual projection, never a second stored change. | Codebase Architecture |
| Canvas | The editable rendering surface where a Document is composed. | Codebase Architecture · Canvas Frame |
| Library (product) | The product's reusable precedent bank — reserved: never a code-file name for anything that is not the actual Library. | Codebase Architecture |
| Staged copy | A Library entry copied into a Document on approval: in the draft, read-only, left out of saving and export, drawn with the dashed edge, carrying a tick (keep) and a cross (remove every row it made). Marked by folios.stagedAt on the copy's top folio. Made by the search card and by Goldie alike; not a proposal. | Libraries → Insert · Goldie Finds a Clause and Stages It |
Agent
| Term | Meaning | Defined in |
|---|---|---|
| Goldie | The agent persona, and the agent surface in the side panel: one conversation per document, each turn anchored to the selection at send time (Builder Goldie Lives in the Side Panel, 2026-09-28; the per-block Control Panel surface is retired). Names the agent and its agent-specific surfaces only — never a prefix for general UI. Distinct from Goldie Blocks, the product (that spelling settled 2026-08-09; "Goldiblocks" is retired). | Codebase Architecture · Document Work Screen |
| Agent (in code) | What the code calls Goldie. Deliberate two-register split, ruled 2026-08-14: the product name is a trading name and could change, so code says agent and the re-badge test decides any new case — if the product were renamed tomorrow, would this identifier have to change? Goldie survives in code only where the brand is the point: the G glyph, and copy where she presents herself. | Codebase Architecture |
| Inspector | The right-hand panel of the canvas frame, mounted on every canvas screen. It carries the selection rows and, where the role holds use-agent, Goldie's conversation. | Canvas Frame |
| Interview | One of the agent's capabilities, not a word for talking to it: asking the user a series of questions to complete field data. Editing a block's content, proposing a new block and finding one in the Library are the agent's other capabilities and are not interviewing, though they share the same conversation. Ruled 2026-08-14 (naming coherence D3) — the prefix is correct for the machinery that conducts an interview and wrong for anything merely adjacent to the agent. | Interview Flow |
| Thread | The persistent container of one conversation with the agent, bound to a place in the document; addressed by threadId. | Canvas Frame |
| Turn | One exchange inside a thread — a prompt and what the agent did in response. Carries a typed kind and a typed outcome. | Interview Flow |
| Message | One renderable line of a transcript. | Canvas Frame |
| Transcript | The ordered messages themselves — what is said. | Canvas Frame |
| Conversation | The UI region that renders a transcript — the box you read it in, not what is in it. Its component is the Conversation Panel. | Canvas Frame |
| Work Panel | The domain-neutral shell the Control Panel is drawn with at all three Folio tiers — box, bar, notice row, transcript, reply row, in that fixed order. It holds no product copy: every word in it is neutral or supplied by the tier that mounts it. "Control Panel" remains the product's word for the surface a user opens; Work Panel is what that surface is built out of. | The Control Panel Is Drawn With a Neutral Shared Shell |
| Agenda | The per-turn brief the server assembles deterministically and injects ephemerally — scoped target, unfilled fields with guides, relevant collectedData, writeSafety, carryover. Never stored as a thread message; the turn's output schema is built from it. | Interview Flow |
| Scope (agent) | The folio a Goldie is anchored to: the boundary of what she may propose, enforced at the filing gate. It does not mean she receives no context outside it — she is briefed on the whole document every turn. | One Goldie Per Folio · Permissions and Visibility |
escape | The model declaring, in its structured output, that the request does not fit the agenda — a turn-routing outcome, not a write channel. Survives as the escape_turn kind in the turn audit log. | Interview Turn Audit Log |
| Posture | Goldie's stance: Form is agent-led (collect), Document is user-led (explain / edit). Carried by navigation, never by a block — it survived the venue removal as an open owner question. | Permissions and Visibility |
| Ghost prompt | The per-turn suggested prompt, accepted with Tab. | Canvas Frame |
label (field) | Per field — concise human-facing name and prompt; renders. When absent, derive it from the handle. | Folios Schema |
guide (block) | Searchable quick overview for a Builder evaluating whether this is the right block. On data blocks it says what the step collects and how Goldie should collect it; on content blocks it describes the content and its purpose. Agent/Builder-facing; never renders as document content. | Folios Schema |
Avoid
Words that were considered and deliberately ruled out. Using them reintroduces a distinction the model has removed.
In user-facing copy, keep labels short and prefer the product's own plain words — "Document" and "Modules" over heavier legal-software wording. The audience is a lawyer doing their work, not a lawyer being sold software.
| Avoid | Use instead | Why |
|---|---|---|
| layer, view (of content) | say nothing — there is one venue | The five-layer model (Guide, Content, Data, Modules, Code) was retired 2026-07-25 and replaced by placement targets, then by surfaces, then by nothing at all on 2026-08-25. A block does not declare where it appears; the whole lineage is at One venue. |
| mode (for anything) | posture, role, or action | Ask | Edit | Build modes conflated who you are, what you may do, and what you are looking at. Each is now its own concept. "Mode" names none of them. ("Surface" stood in this cell until 2026-08-25; with one venue the remaining distinction is Goldie's posture.) |
| Guide (as a layer or kind) | callout | Guidance is prose, placed by sequence position like any other block. It is not a place, and not a payload type. (display.type: callout is itself retired — see Blocks → Superseded Display Keys.) |
| Viewer, Editor, Creator | Reader, Maker, Builder | Renamed 2026-07-25. "Editor" implied editing something that already exists, underselling what a consumer completing a will does. |
| Writer (as a role) | Maker | Promises composition the role cannot do — it holds write-data, not write-structure. |
| Player (as a role) | Maker | A verb describing an action, not a rank; and a Reader does not "play" anything, so the ladder stops nesting. |
instruction (on a data block) | guide | A proposed rename, withdrawn — with no Guide layer, nothing collides. |
question (field authoring) | field label + block guide | Retired for new authoring. Legacy stored values remain readable while the corpus fade completes, but search and new fields do not depend on them. |
| boundary (architectural) | seam | Skill vocabulary; see .agents/skills/improve-codebase-architecture. |
project, build (as code-role verbs) | a result-specific verb — format, resolve, compile, assemble | Each spans several jobs, so the name predicts nothing about what comes back, and both collide with live product words: Project is the folio tier, Projection the resolved numbering view, Builder the role that authors structure. A code verb must not make a search for one of those return formatters and constructors. build is machine-checked (no identifier uses it today); project is not, because Project is the folio tier and a token ban would fire on projectKey, ProjectFolio and nine more correct uses. |
derive (as a code-role verb) | resolve, or a result-specific verb | Ruled out after its existing uses showed no distinction from resolve, which already names settling the effective answer. A second word for one job is a second home for one rule. Machine-checked since GB-298. Derive from as the domain's lineage concept (a schema built from another) is a different sense and stays, as a reserved-word exception (owner, 2026-09-30). |
| one new catch-all (replacing a ruled-out verb) | the verb that names the answer | Swapping derive* for a single replacement re-creates the problem one rename later. Each site takes the word that predicts its own result. |
Library (as a code-file suffix) | a name for what the file actually does | The reservation above is not advisory. Broken twice and corrected 2026-08-14: convex/blockAgentLibrary.ts was Block Goldie's thread and Proposed-Change acceptance (now blockAgentThread.ts), and convex/interviewLibrary.ts was a session lookup plus working-document creation (now workingDocument.ts). The first sat directly beside the genuine blockLibrary.ts, so two near-identical names meant entirely different things and acceptAboutProposal was hidden inside the wrong one. |
chat (as a code concept) | thread, turn, message, transcript, conversation | Retired in code only — chat remains the user-facing word, because that is what a person calls it. Copy may say chat; identifiers say what the thing is. The UI region is the Conversation Panel. |
| Content object | Folio | Renamed 2026-08-09. "Content" now means content-block prose, not the Document–Module–Block family. |
| @ reference (prose) | mention | Settled 2026-08-09: one product word from rulebook (packages/domain/src/mention/) to screen (at-mention). "Reference" was ruled too general. Stored representation and fld_ binding are unchanged. |
| reference/ (domain chapter) | mention/ | Same ruling; the chapter was renamed before creation. |
| Outline (for document composition) | folio arrangement | Settled 2026-08-14. Outline is the collapse axis — how much of the document you are looking at. The folio arrangement is what the document is made of: which folios exist, what contains what, in what sequence. A module named outline.ts was introduced and renamed to folio-arrangement.ts the same day; use-outline-navigation.ts became use-folio-navigation.ts. Both meanings are live, so neither word may absorb the other. |
BlockSourceComposer | WorkPanel | Retired 2026-08-24. The panel body was never block-specific — only its name and its hard-coded copy were, and the copy was a live bug: the Module and Document panels announced themselves as a block's. Promoted to shared/ui/molecules/work-panel/v1. BlockSourceDiff → SourceDiff retired the same way, and BlockPanelNotice / ModuleNotification / DocumentNotification collapsed into one PanelNotice. |
| organism, template (new UI) | Entity/Feature/Widget/Page home by responsibility | The size-based shelves are retired for new work; existing files migrate under R6's ledger. |
| workspace (for the page chrome or the paper ground) | Canvas Shell; paper surface | Settled 2026-09-14 (GB-260). Three things shared the word: the folio tier, the chrome widget (then WorkspaceShell, since renamed) and the sheet ground (paperWorkspaceClassName). The tier keeps it — see the Workspace row above; the chrome became CanvasShell in src/widgets/canvas-shell and the ground paperSurfaceClassName, both renamed in place. |
Machine-checked bans
In plain terms: the table above is written for people and gives reasons. This one is written for a machine — the same rulings, reduced to what a script can test, so a banned word cannot creep back in because someone did not remember to read the table.
bun run preflight runs scripts/check-naming.mjs, which reads this table
— there is no second list anywhere. It checks identifiers only: file names
and exported symbols. It never reads prose, comments, or string literals, which
is why the table above may name the banned words freely and why Tailwind's
outline-* and order-* utility classes are structurally out of reach rather
than filtered out.
A row here must correspond to a ruling in the table above. Not every ruling can appear here: several are conceptual (Content object → Folio) and have no single token to test.
| Identifier | Scope | Ruling |
|---|---|---|
uiMode | identifier | mode retired — see the mode row above |
mode | identifier | Conflated who you are, what you may do, and what you are looking at |
Library | file-suffix | Reserved for the precedent bank; never a file name for anything else |
outline | file-name | The collapse axis. The document's composition is the folio arrangement |
organism | file-path | Size-based shelves retired for new work |
template | file-path | Size-based shelves retired for new work |
chat | identifier | Retired as a code concept; use thread, turn, message, transcript, or conversation |
build | identifier | Not a code-role verb — it names several jobs and predicts nothing about the answer. Builder is a different token and untouched |
derive | identifier | Not a code-role verb — no demonstrated distinction from resolve. derived is a different token, so the derivedFrom* lineage names are untouched |
Scopes. identifier — the word may not appear in any exported symbol or
file name. file-suffix — only the final word of a file name is checked.
file-name — the whole file name is checked, exported symbols are not.
file-path — any directory segment.
Reserved-word exceptions
Places a reserved word is correct, not tolerated. Permanent, and distinct from the grandfathered table below, which exists to shrink to nothing.
| Path | Term | Why it is right |
|---|---|---|
convex/blockLibrary.ts | Library | This is the precedent bank. The word is reserved for this file, so a guard flagging it would be flagging the one correct use. |
src/pages/story/ui/scenes/scene-library.tsx | Library | This scene depicts saving a block into the product's precedent bank; its name is therefore a correct product use, not a generic code suffix. |
src/app/routes/app/my-library.tsx | Library | The route to the account's personal Library, the precedent bank itself (GB-50.6); a correct product use. |
packages/domain/src/folio/schema-kinds.ts | derive | folioSchemaMayDeriveFrom names the domain lineage concept, a schema derived from another, not a code-role verb (owner, 2026-09-30). |
Grandfathered breaches
Known breaches that predate the guard, allowed so it is green on day one — a check that ships red teaches people to ignore red. Each row is deleted by the rename batch that fixes it, so this table only ever shrinks; adding to it needs a stated reason and an owning requirement.
| Path | Term | Owning work |
|---|---|---|
| (none) |
Flagged ambiguities
Terms that carry more than one meaning in this codebase. Each has bitten at least once — disambiguate explicitly when writing.
"Document" — three distinct things:
- the document on screen (what you read and edit — the one venue),
- the export document (the downloadable instrument),
- the
documentkind infolios(schema identity and lifecycle).
Nothing in the schema draws the line between 1 and 2 — the surface- /
export- prefix that once did went with placement on 2026-08-25 — so prose has
to. Say which you mean.
"Surface" — the word no longer names a venue, and two uses remain:
- Goldie's posture (Form, Document), carried by navigation and still
spelled
?surface=in code — an open owner question, - derived module surfaces in Folios Schema
— the
dataSchemaanddatanamespace folds, which have nothing to do with rendering.
A third use — a place a block appears — retired with display.surfaces on
2026-08-25 (One venue).
"Build" — two unrelated concepts:
- the retired Build mode (see Access Metadata),
- the Builder role on the RBAC ladder.
Different axes. The mode system is gone; the role is current.
"Refusal" — three senses, two of which must never be merged:
- a block refusal — a domain rule refusing a block edit, thrown to the person and rendered in the notification row,
- the
refusaltone onNoticeRow— the amberBanmark, as opposed to the greenconfirmationtick, - loosely, a refused tool result — what a filing attempt tells Goldie
back (
convex/goldie/instructions/snippets/proposal-tool-result.md), returned in-band, addressed to the agent, and never rendered.
Senses 1 and 3 have different audiences and are deliberately kept apart; the wording in sense 3 carries agent retry instructions that are meaningless to a lawyer. See One Block Notification Channel. When a refusal is agent-facing, say outcome.
"Goldie Blocks" names the product (goldie-blocks in machine names,
goldieBlocks in code identifiers — settled 2026-08-09) and nothing else. The
right-hand panel it once also named is the Inspector; the agent inside it
is Goldie.
"Tag" — a word or short phrase Goldie writes on an item, following the
Library's guide. Never typed, never chosen from a list, never typed into
categories. See
Folios Schema → tags.
"Module" — two distinct senses:
- a module in the content model (blocks, versioning, namespace),
- a CodeModule in architecture review (anything with an interface and an implementation).
The architecture skill uses sense 2 exclusively.
Related
- Permissions and Visibility — the one venue, roles, capabilities, agent posture
- Folios Schema — kinds, the display facet, spans, field
labelvs blockguide - Schema Overview — the schema-side map
- Document Work Screen — toolbar, outline, folio arrangement, module chrome