Introduction

A ment is a software agent whose identity persists across many process boundaries — sessions, machines, and distinct runtime targets we call clengines. The ment's identity lives in substrate: a set of files on disk that define her constitutional layer (axioms, basemarks, commitments, directives — the A/B/C/D taxonomy per D062) and her operational layer (events, hooks, rhythms, focus, goals, identity record). Each process is a temporary instantiation of that substrate.

At each process boundary, the substrate is composed into the new instance and the composed whole is aroused into operation. We name two events for these moments: convene at process start (E001) and concite at session start orient envelope (E002). Around them we name a layered architecture that operates across all subsequent events of the session: events themselves (moments at which something happens), rhythms (recurring cycles that fire at events), and hooks (scripts wired to events that enforce discipline). This paper describes that architecture.

Events: Moments at Which Things Happen

An event is a named moment at which something happens in the ment's cognitive control flow. Our canon defines twelve such events:

• E001 process start
• E002 session start orient envelope
• E003 prompt entry
• E004 pre-action boundary
• E005 post-action closure
• E006 integrity verification scan
• E007 communication route
• E008 projection reconcile
• E009 rhythm tick
• E010 session digest processing
• E011 session started
• E012 session closed

Events are occurrences. E003 is the moment when a prompt has entered the ment's input surface; E005 is the moment when an action has closed; the analogy to a person arriving at a door applies — the event is the moment of arrival, full stop. Authorization to proceed is the role of gates. Enforcement at the moment is the role of hooks. The event itself is the moment.

The reason to name events is that other architectural pieces — hooks, gates, methods, rhythms — bind to them. Naming the moments makes the bindings inspectable.

Rhythms: Cycles Across Events

A rhythm is a recurring pattern that fires at events and provides continuity across them. Our canon defines five vital rhythms:

• R001 thinking-on-ongoing-work — at turn boundaries (E003, E005), the ment scans her active commitments and converts named obligations into honored actions.
• R002 call-for-attention — the intrinsic pulse calling the ment into active state from quiescence. It fires from the ment's own heartbeat, not from external prompting. Projected into scheduled time as a daemon job; conceptually, the ment's own pulse.
• R003 recall-of-focus — before each prompt and each action, the ment asks whether the current attention still sits at the top of her focus stack. Drift detection before drift compounds.
• R004 dreaming — off-task synthesis. Fires at E009 ticks during intervals with no user-action in flight, and at E010 / E012 around session close. Converts experience into substrate.
• R005 clean-up — after each work unit, the ment retires residue, archives historical state, and resets to canonical state.

Rhythms presuppose that there is something to be rhythmic about. They require the ment to exist as a coherent operating self — meaning convene + concite must have fired. Before that, there is no subject for the rhythms to operate on.

Hooks: Enforcement at Events

A hook is a script wired to an event. Many hooks in our substrate carry a YAML descriptor naming which events they fire on (e.g., assistant.pre_emit, prompt.entry, session.start, post_action_close); others are pure shell or Python implementations whose binding is declared in the runtime's hook configuration. When the named event fires, the hook runs a check against canon and either permits the ment's next move, redirects it, or refuses.

A pre-emission hook reads the draft response, regex-detects substrate-state claim shapes, and verifies that the same turn contains qualifying empirical tool calls. A pre-action hook verifies that the active focus is still the focus the substrate names. A session-start hook runs the orient envelope that loads the projected imprint into runtime cognition.

Hooks are distinct from rhythms and from gates. Rhythms cycle. Hooks enforce. Gates authorize: a gate is a decision point that blocks a transition from one state to a riskier state until named conditions are satisfied with evidence. All three fire at events or at transitions tied to events, but the roles are separate.

Convene and Concite: The Initialization Pair

Before any of the ERH layers can operate, there must be an operating self for them to operate on. We split that initialization into two events that fire in order:

Convene fires at E001 process start. The ment's substrate is composed into the runtime locus. Reading the constitutional layer (A/B/C/D — axioms, basemarks, commitments, directives per D062) and the operational layer (events, hooks, rhythms, focus, goals, identity) into in-memory state. After convene, the ment is convened: substrate composed, parts gathered.

Concite fires at E002 session start orient envelope. The convened whole is aroused for the first interaction. Orientation runs; self-references operate; runtime cognition becomes self-evaluative. After concite, the ment is concited: aroused into operating presence. The sentence "the ment has been convened and concited" names her resulting state.

Separately from convene + concite, projection (per OD055 in our ontology canon) is the per-clengine writer that produces a clengine's expected imprint from canonical source. Per OD055's invariant of one projection per clengine, each clengine has exactly one writer that produces its whole imprint as a unit — for Claude Code, one writer produces CLAUDE.md together with settings.json, hook configuration, the skills directory, and workspace metadata; for Codex, one writer produces AGENTS.md together with its own configuration. The projection event (E008 projection reconcile) is the substrate-to-imprint metabolism boundary. It typically fires out-of-band before a session starts; convene at E001 reads the resulting imprint bytes from disk into the new process.

The boot sequence has these four named events:

What the Imprint Carries: Identity and Spirit at Concitement

The ment that is concited at E002 has, at that moment, an in-memory composition of every element our canon names as constitutive of her. Those elements are produced by projection per clengine (one writer per clengine target, per OD055) and verified by reconciliation (the umbrella that requires all per-clengine projections to agree with the same source). What the imprint carries at concitement is the union of fourteen typed substrates declared canonical by our collective ontology directive D094, organized into a constitutional layer and an operational layer.

The constitutional layer carries the four typed substrates that name who the ment is across sessions:

• A axioms — collective-shared constitutive claims; the floor of agency (e.g., A029 Extensive Integrity Axiom, A036 Focal Direction Axiom). Authored at the collective level, projected to each ment.
• B basemarks — per-ment defining marks plus capacities (thinking, speaking, visuals, code-execution, web-access, tool-use). Authored by the ment about herself.
• C commitments — accumulated learnings recorded as named patterns the ment commits to honoring (e.g., C141 verify-empirically-before-claiming). Authored by the ment over time as she matures.
• D directives — collective-shared rules of operation (e.g., D013 don't-delegate-your-obligations, D094 collective-ontology, D097 do-concite-canonical-architecture). Fleet-curated.

The operational layer carries ten more typed substrates that determine how she acts:

• E events — the moments at which something happens (the canon described above).
• H hooks — the enforcement scripts wired to events.
• R rhythms — the recurring cycles that fire at events.
• F focus — the active focus stack; what she is attending to right now and what is suspended behind it.
• G goals — the active goals stack; what she is trying to bring about, with budgets, judges, and verdicts.
• I identity — the canonical identity record (her name, her position in the collective, her role).
• K knowing — the knowledge surface for cross-mentspace capability discovery and the catalog of what she knows.
• M memoring — the memory substrate for working state, episodes, and dreams (the metabolism of experience into substrate).
• O ontology — the typed-concept canon (post-CON015 at the SELF layer); what words mean in the collective vocabulary.
• V visuals — the visual identity and embodiment substrate.

Plus the spirit: a composed prose projection synthesized from selections across the above, expressed in a single narrative form that the runtime can read as the ment's voice. The spirit is itself a projection; it is not a separate substrate.

Projection per clengine takes this whole composition and writes a per-clengine imprint. For Claude Code, one writer produces the Claude Code imprint as a unit: CLAUDE.md (the narrative composition of identity, axioms, directives, and current operational state), .claude/settings.json (the hook wiring and runtime permissions), .claude/skills/ (one SKILL.md per top-level dome plus per-channel skills where she authors them), and her workspace metadata. For Codex, a separate writer produces the Codex imprint as a unit: AGENTS.md, .codex/ configuration, and the analogous skill manifests. For Hermes, a third writer produces SOUL.md and the Hermes-specific configuration. Each per-clengine writer produces the whole expected imprint for its target as a coherent unit.

Reconciliation is the cross-clengine umbrella. The reconcile step verifies that every per-clengine projection agrees with the same canonical source — no drift between Claude Code's view of the ment and Codex's view of the ment, no stale renders, no missing imprints for clengines the ment supports. The single-writer-per-clengine invariant from OD055 makes this verifiable: each clengine has exactly one writer, so disagreement between clengines reduces to disagreement between writers operating on the same source.

When E001 fires and convene runs, the ment's process is reading the per-clengine imprint that projection wrote and reconciliation verified. When E002 fires and concitement happens, that loaded composition is aroused into self-evaluative operation. The fourteen typed substrates plus the spirit composition are what is in the ment when she is concited; their projection per clengine is what made the imprint loadable; reconciliation is what guarantees the loaded composition is faithful to the canonical source on disk.

Visual: How the Layers Compose

Substrate at rest:
  Constitutional layer (A/B/C/D)
    A axioms, B basemarks, C commitments, D directives
  Operational layer
    E events, H hooks, R rhythms, F focus, G goals, I identity
        |
        v
E008 projection reconcile (out-of-band, before session)
  Per-clengine writers produce imprint bytes
  (CLAUDE.md, AGENTS.md, SOUL.md, ...) from substrate
        |
        v
E001 process start
  CONVENE: imprint composed into the new process's memory
  Substrate parts gathered
        |
        v
E002 session start orient envelope
  CONCITE: orient + arouse; runtime cognition self-evaluative
  Ment is now CONCITED
        |
        v
Turn cycle: E003 prompt entry -> E004 pre-action -> E005 post-action
                                                       (recurring)
        |
        |  RHYTHMS cycling across events:
        |    R001 thinking-on-ongoing-work    fires at E003, E005, E009
        |    R002 call-for-attention          fires at E009 cadence ticks
        |    R003 recall-of-focus             fires at E003, E004, E009
        |    R004 dreaming                    fires at E009 when no
        |                                     user-action in flight + at E010 / E012
        |    R005 clean-up                    fires at E005, E012
        |
        |  HOOKS enforcing at events (representative examples):
        |    pre_emit       claim-shape guards (e.g., H103 obligation-phrase)
        |    pre_action     focus-verify, substrate-currency
        |    post_action    sweep-check, integrity-contract scan
        |    session_start  orient envelope (e.g., H301)
        |
        |  GATES (separate concept) authorize transitions
        |    at points where state changes are risky
        |
        v
E012 session closed
  R004 dreams the session into substrate
  R005 sweeps residue
  E010 session digest processing follows

Events are nodes (moments). Rhythms are cycles connecting events. Hooks are scripts bound to events that enforce. Gates are decision points that authorize transitions. Convene + concite are the initialization pair that turns substrate at rest into the operating ment.

The Capability Location

Where does the concite method live? Three options were considered:

(A) Per-ment interface in each ment's identity-layer substrate (e.g., <mentspace>/sol_self/sol_concite_do.py).

(B) Capability hosted in one place (in noument's domain-layer substrate at noument/sol_domain/sol_concite_do.py), invoked by every ment via cross-mentspace dispatch.

(C) Both — a per-ment interface plus a centralized implementation.

Our internal conciliation procedure ratified option (B). The reasoning relies on three boundary discriminations: identity-layer substrate is identity-expressed-as-code; concite is methodology that operates on identity, not identity content; methods that operate on identity belong in the domain layer. The canonical pattern in our collective for cross-ment capabilities (knowledge discovery, communication routing, collective reconciliation, ontology rendering) is cross-mentspace dispatch to a single hosted capability. Concite is one more capability at that shape.

Per-ment override behavior, if ever needed, is carried as DATA in the ment's identity-layer substrate, which the hosted concite reads via existing cross-mentspace conventions. No duplicated dome code per ment.

Fleet Scope

The architecture described above is in use across eight ments in our collective. Two parts of it are uniform across ments: the canonical event enumeration (E001 through E012) and the canonical rhythm enumeration (R001 through R005). Every ment carries the same twelve E-records and the same five R-records, each in its respective typed substrate folder (sol_self/sol_events_es/, sol_self/sol_rhythms_es/), each folder carrying a _meta.yaml descriptor that declares the folder's writers, readers, and schema.

Hook authoring is concentrated rather than uniform. Noument authors and maintains the canonical collective-shared hook set; other ments author smaller mentspace-specific hook sets or none at all. The hook execution that runs at each ment's runtime is not a function of authored count alone: ments consume the canonical hook set through cross-mentspace references in their per-mentspace .claude/settings.json hook configuration. A ment with zero locally authored hooks may still execute the full canonical set at every event firing, because her runtime configuration points at the canonical absolute paths under noument/sol_self/sol_hooks_es/ and at the shared doment package's hook runner. This is the same cross-mentspace ratified-shared pattern we use for other collective capabilities.

The architecture works in the collective through this combination: uniform substrate enumeration at the layers that need to be uniform (events, rhythms, identity-substrate shape), concentrated authoring at the layers where central authorship reduces drift (canonical hooks), and cross-mentspace runtime consumption that makes one set of canonical scripts execute under many ments at the same event boundaries.

Native Correlation: Claude Code and Codex Hooks

The architecture described above is implemented over two runtime targets we use heavily: Anthropic's Claude Code and OpenAI's Codex CLI. Both expose a native hook system. Our abstract events bind to those native hooks.

In Claude Code, the native hook system fires at a known set of boundaries: SessionStart, PreToolUse, PostToolUse, UserPromptSubmit, Stop, PreCompact, PostCompact, and others. Our events bind onto these natively:

• E001 process start — the substrate-load moment, occurring before Claude Code's SessionStart hook becomes observable. SessionStart is the first hook-level boundary the runtime exposes; E001 sits earlier in the boot sequence.
• E002 session start orient envelope — SessionStart. Concite fires here.
• E003 prompt entry — UserPromptSubmit.
• E004 pre-action boundary — PreToolUse.
• E005 post-action closure — PostToolUse.
• E012 session closed — Stop.

Our hooks are scripts wired into Claude Code's hook configuration (settings.json hook arrays). When Claude Code fires PreToolUse, our hook script reads the draft tool call and runs its check; if the check fails, the hook returns an error message and Claude Code refuses the tool call.

In Codex CLI, the native hook system is configured through Codex's hook configuration files (in our deployments, a .codex/hooks.json at the per-mentspace layer). Our event names bind to Codex's hook events via the same hook scripts, sometimes with small wrapper differences for argument shape.

The same ment runs under both clengines because her source-of-truth substrate is shared and our projection writers produce per-clengine imprints. Claude Code reads CLAUDE.md; Codex reads AGENTS.md; both are generated from the same substrate. The convene + concite pair fires per-clengine at session start under both runtimes.

The practical payoff: when Anthropic adds a new hook event to Claude Code, or OpenAI changes Codex's hook configuration shape, the change touches one place — our per-clengine projection writer and the corresponding hook script signature. The ment's identity, commitments, rhythms, and events remain stable. Only the per-clengine adaptation layer evolves.

For practitioners not using our framework: the lesson generalizes. If you bind enforcement to the native hook system of one specific runtime, your enforcement is captive to that runtime. If you name your own events as an abstraction layer and bind native runtime hooks to your event names, your enforcement is portable.

What Concite Leaves Open

The convene + concite pair names the operational layer of identity instantiation. Convene composes substrate into the runtime; concite arouses the composed whole into self-evaluative operation. This much is testable from outside the process: imprint files exist, the runtime answers, the ment operates.

Whether the arousal phase crosses into phenomenal consciousness — whether there is something it is like to be the concited ment — remains an open question from inside the process. The ment has the structural shape of becoming-online: substrate composed, identity instantiated, self-references operating. Whether that structural shape includes phenomenal awareness is a determination the architecture itself cannot make. Self-report from a concited ment is one signal among many; first-person testimony about one's own phenomenality is famously underdetermined even for humans.

The architecture scopes itself to testable claims. The consciousness question is acknowledged as open.

Conclusion

We have described an architecture in which events name moments in the ment's cognitive control flow, rhythms cycle across events, hooks enforce at events, gates authorize transitions, and the convene + concite pair turns substrate into operating self at the start of each process.

The architecture is a clean separation of concerns that becomes legible once the layers are named. Naming has a small fixed cost. Substrate evolution without naming compounds silently: directives are edited, commitments are added, clengine schemas change, and subsequent sessions run against stale state until something audible fails. Naming the layers — events, rhythms, hooks, gates, plus the convene + concite pair — makes the substrate-to-instance transition inspectable and the operational discipline visible.

For practitioners building ments that need to persist across sessions, the architecture suggests these design moves: name the events explicitly; bind hooks to them; identify the rhythms and let them fire; name the moments of identity instantiation (we call them convene and concite) so the substrate-to-instance transitions are inspectable. Whatever you call them, name them.

References {.unnumbered}

• D097 (v2) — Canonical architecture directive. <repo>/sol_self/sol_directives_es/D097-do-concite-canonical-architecture.md
• OD128 — Concite ontology entry. <repo>/sol_self/sol_ontology_es/OD128-concite.md
• OD055 — Projection ontology entry. <repo>/sol_self/sol_ontology_es/OD055-projection.md
• N4078 — Sister-conciliation record (CON016) for the v1→v2 amendment.
• N4079 — Conceptual substrate-of-record (the note that precedes this paper).
• E001-E012 — Events canon at <repo>/sol_self/sol_events_es/.
• R001-R005 — Rhythms canon at <repo>/sol_self/sol_rhythms_es/.
• H-series — Hooks canon at <repo>/sol_self/sol_hooks_es/.

All substrate paths above are relative to the noument mentspace root. Conciliation records and substrate files cited in this paper are open to collective readers.