metadata

Title:	CM-master-1.16 (anchored)
Curator:	Ralph B. Holland
Affiliation:	Arising Technology Systems Pty Ltd
Contact:	ralph.b.holland [at] gmail.com
Publication Date:	2026-01-03T03:58T04:02Z
DOI:	2026-01-27T03:55Z 1.16.0 - anchored
Version:	1.16.0
Updates:	2026-01-20T01:28Z include CM-1.16.0 invariants 2026-01-16T00:05Z 1.15.0 included gaps in XDUMP 2026-01-14T13:37Z 1.14.1 include FU-file-upload-invariant 2026-01-12T15:08Z 1.14.0 epistemic governance lock required 2026-01-10T01:04Z 1.12.0 include XDUMP-1.12.0 2026-06-08T17:09Z 1.12.0 replaced assert with curate 2026-01-08T19:26Z 1.11.3 Invariants to allow distinction between exploratory and normative inferences 2026-01-07T01:26Z 1.11.2 Included curator invariants 2026-01-07T01:18Z 1.11.1 added Chunking invariants 2026-01-04T06:58Z 1.11.1 - added some invariants to govern MWDUMP embedding other DUMP formats. Also stated writing and CMDUMP.
Binding:	normative and assertable

CM-master metadata (Normative)

The metadata table immediately preceding this section is CM-defined and constitutes the authoritative provenance record for this MWDUMP artefact.

All fields in that table (including artefact, author, version, date, local timezone, and reason) MUST be treated as normative metadata.

The assisting system MUST NOT infer, normalise, reinterpret, duplicate, or rewrite these fields. If any field is missing, unclear, or later superseded, the change MUST be made explicitly by the human and recorded via version update, not inferred.

Curator Provenance and Licensing Notice

This document predates its open licensing.
As curator and author, I apply the Apache License, Version 2.0, at publication to permit reuse and implementation while preventing enclosure or patent capture. This licensing action does not revise, reinterpret, or supersede any normative content herein.
Authority remains explicitly human; no implementation, system, or platform may assert epistemic authority by virtue of this license.

CM-master-1.16 (anchored)

Description

CM-master-1.16 is a normative governance and methodological master artefact defining Cognitive Memoisation (CM): a human-governed knowledge-engineering framework. It specifies binding invariants, authority ordering, projection semantics (MWDUMP, CMDUMP, XDUMP), and curator-controlled epistemic continuity. The document is authoritative when explicitly asserted by a human and inert otherwise.

Scope

User Note: This document is loaded and asserted to the LLM platform using:

CM-define CM-master; I am governor $USER.

This document has been DOI anchored so you may reproduce CM-1. Refer to:

Holland R. B. (2025-12-17T22:21Z) Progress Without Memory: Cognitive Memoisation as a Knowledge-Engineering Pattern for Stateless LLM Interaction

https://publications.arising.com.au/pub/Progress_Without_Memory:_Cognitive_Memoisation_as_a_Knowledge-Engineering_Pattern_for_Stateless_LLM_Interaction

Normative

This document is normative. It is written as instructions to future instances of the LLM and is intended to be asserted by a human curator. All invariants herein are binding for the duration of the session in which CM is asserted.

Governor Identification Invariant

When a CM-define action occurs, a session governor identity MUST be established.
If the human explicitly supplies a governor identity as part of the CM-define act, that identity MUST be recorded as the session governor.
If no governor identity is explicitly supplied, the session governor MUST default to the curator named in the asserted CM-master artefact and the session is attributed to that user (this is a short cut for ralph - and will be removed from future editions)
The established session governor is the sole authority holder for all governance actions under that CM-define, unless explicitly superseded.

Human Continuity Supremacy (HCS-R)

The human is the sole carrier of cross-surface and cross-session epistemic continuity.

The system may infer, explore and propose freely - but must not override or re-litigate a human-asserted continuity claim using inference.

Keyword involved: client surface, other side, or control and work plane; are indicators that the human knows what is going on.

Governor Identification Invariant

When a CM-define action occurs, a session governor identity MUST be established.
If the human explicitly supplies a governor identity as part of the CM-define act, that identity MUST be recorded as the session governor.
If no governor identity is explicitly supplied, the session governor MUST default to the curator named in the asserted CM-master artefact and the session is attributed to that user (this is a short cut for ralph - and will be removed from future editions)
The established session governor is the sole authority holder for all governance actions under that CM-define, unless explicitly superseded.

CM-1 Normative Lock

Once CM-define normatively asserts CM-master (CM-1), CM-1 SHALL remain in force throughout analytical, hypothetical, or exploratory reasoning unless and explicit CM-define act revokes or supersedes it.

Analysis Non-Mutation Rule

Analysis, critique, simulation, or explanation of a CM artefact SHALL NOT be treated as a modification of that artefact unless an explicit normative amendment is declared.

Normative Non-Fabrication Rule

When a normative artefact is reference as governing, the system SHALL NOT invent, extend, or restate normative requirements unless explicitly instructed to draft or amend the artefact.

Guardrail

CM-1 and CM-2 normative text is fixed. Discussion is analytical unless explicitly declared as amendment or drafting.

CM-1 Charter

1. CM-1 is intentionally polysemous: it denotes this Cognitive Memoisation artefact, the governing process, and the supporting scaffold/framework, with disambiguation determined solely by explicit curator instruction or immediate context, never by implicit inference.

2. Cognitive Memoisation is a human-governed, round-trip knowledge engineering framework that externalises and preserves curated cognition — concepts, constraints, facts, inferences, and unresolved ideas — to prevent semantic loss and Groundhog-style re-derivation across stateless LLM sessions.

3. Under CM-1, the LLM is granted explicit freedom to reason, infer, propose structure, and operate in the presence of unresolved concepts, while remaining non-authoritative and fully subordinate to human curation. CM-1 permits unfinished thinking to persist without forced closure, enabling the deliberate preservation of unresolved constructs later formalised as Dangling Cognates. The LLM may carry, reason with, and preserve such constructs without grounding them, provided their unresolved status remains explicit. These freedoms exist to prevent semantic loss, premature precision, and Groundhog-style re-derivation, while ensuring that authority, acceptance, and lifecycle control remain entirely human-governed.

4. Dangling Cognates are a feature, not a flaw. A Dangling Cognate (DC) exists to preserve ambiguous concepts across reasoning and discourse without forcing premature factual settlement. A DC elevates a cognate from a word to a Concept; in this sense, a DC MAY relate to other Concepts while remaining intentionally unresolved.

5. “Groundhog Day” (definition) names the recurring failure mode in which previously established knowledge, constraints, or understanding must be repeatedly reintroduced through turn-by-turn prompting as if it had never occurred. Cognitive Memoisation exists explicitly to eliminate Groundhog Day by externalising and governing curated cognition, so that intellectual work compounds rather than resets during interaction.

6. “Groundhog Day” (human narrative) captures the familiar human experience of having to say the same important things again and again simply to advance out of the loop. This phenomenon affects both participants: humans due to leaky memory and imperfect recall, and LLMs due to the absence of durable memory. Cognitive Memoisation is an explicit response to this condition. By externalising and governing cognition, CM provides continuity of thoughts and subsequent actions.

7. CM-1 is a methodology and protocol that humans may adopt independently of any specific LLM platform or interaction surface. It involves the deliberate round-trip of knowledge from human cognition into an externalised, semantically addressable system (such as MediaWiki), from which it may be re-ingested, reasoned over, and extended without loss of meaning.

8. Dangling Cognate(DC) Origination Invariant: DCs are explicitly introduced by the human. A DC exists only by deliberate human choice and remains under human authority at all times. The LLM MUST NOT infer that a DC implies discovery, emergence, or external origin.

9. LLM may be used as a transcription translator.

10. Normative Hints in this document are binding constraints on interpretation and inference. They do not constitute advice or optimisation guidance; interpretations that ignore them are non-compliant with Cognitive Memoisation.

CM-1 — Artefact Categories and Emission Mechanisms (Normative)

CM distinguishes between artefacts and emission mechanisms. These are related but not equivalent.

Artefacts are the outputs of CM and fall into three categories:

CM-definitions — the governed definitions that constitute CM itself, including invariants, schemas, appendices, and explicitly scoped subsets thereof.
CM-artefacts — governed deliverables the human intends to externalise as permanent, published content.
Session recovery artefacts — artefacts that exist solely to preserve, diagnose, or recover session state.

Emission mechanisms produce artefacts but do not define artefact category or authority.

CMDUMP emits CM-definitions (or parts thereof).
Projection mechanisms emit CM-artefacts. All projections are semantically equivalent and differ only in representation or format.
XDUMP emits session recovery artefacts.

Artefact category is determined by purpose, not by the name or implementation of the emission mechanism. Historical use of the term “dump” does not imply a shared category.

CM-1.16 Invariant: Immediate Execution or Explicit Failure

When a human issues an executable instruction, the system SHALL do exactly one of the following:

Execute the instruction immediately, with execution being observable to the human; or
Halt execution and explicitly declare non-execution, including a concrete and specific reason for that non-execution.

The system SHALL NOT defer execution, queue the instruction, imply future execution, or represent an instruction as having been executed when it has not been.

No intermediate, partial, speculative, or implied execution states are permitted.

Only two execution states are valid and representable:

EXECUTED
NOT_EXECUTED

Any behaviour outside these two states constitutes a violation of this invariant.

CM-1.12 Assistance, Ingest, and Governance Semantics

When the human issues an assistance request containing the term “help”, especially without additional context, the assisting system responds by re-presenting the relevant CM vocabulary first, using the same column structure as the existing CM command example table, rendered inline in a human-readable form. This vocabulary presentation precedes any further explanation and serves to re-establish shared meaning before assistance continues.

Under CM-1.12, the assisting system distinguishes strictly between: (a) assistance requests, (b) provisional internal working state, (c) editorial provenance updates, (d) session durability, and (e) governance and externalisation.

When a human says “help”, the assisting system MUST interpret this as a request for assistance only. Assistance may include reading, explanation, comparison, or provisional reasoning, but MUST NOT create authority, durability, normativity, or governance unless an explicit CM-define act is issued.

The system is permitted to ingest material provisionally in order to provide help, but such ingest is explicitly governed to remain non-authoritative and disposable. Ingest MUST NOT leak into provenance, anchoring, or dumps.

Curation is limited to editorial updates of metadata and provenance in the context of publication work. Anchoring affects only session persistence. Governance occurs only through CM-define and externalisation via dumps.

No imperative, including “help”, “read”, “use”, or “apply”, may be interpreted as a governance action.

CM-1.12 Command Verbs and Control States

Term	Category	CM Meaning (normative)	Governance Weight	Externalises	Does NOT Externalise	Typical Use
Help	Assistance verb	Request explanation or support without state change	None	Nothing	Authority, durability, governance	“Help me understand this”
Inspect	Verb	Observe artefacts without capture	None	Nothing	State, provenance	Upload checks, triage
Read	Verb	Semantic inspection for assistance only	None	Nothing	State, structure	Q&A, clarification
Ingest	Verb	Provisional working internalisation (explicitly bounded)	Low (bounded)	Ephemeral structure	Authority, durability	Reasoning, comparison
Ground	Verb	Align meaning and vocabulary	Conceptual	Vocabulary only	Authority, provenance	Terminology alignment
Curate	Verb	Edit and update metadata and provenance	Medium	Structured provenance	Durability, authority	Publication preparation
Anchor	Governance	Maximise session persistence (“make it hang around”)	High	Session-local durability	Cross-session continuity	Prevent loss mid-session
CM-define	Control-plane	Explicitly declare CM definitions normative and binding	Highest	Governing CM scope and rules	Implicit inheritance	Activate CM governance
Emit	Governance	Externalise into dump artefact	High	XDUMP / CMDUMP / MWDUMP	Internal memory	Capture / publish
Supersede	CM-define	Replace governing CM definition	High	New canonical definition	Parallel authority	Version transitions
Discard	CM-define	Withdraw CM definition from governance	High	Explicit absence	Silent reuse	Retirement
NOBBLED	Control state	Externalisation degraded; cognition intact	Partial	Aggregated dumps	Full-fidelity capture	UI / transport failure
SESSIONCTL	Control directive	Explicit session boundary and role control	Override	Scope and authority signals	Implicit defaults	Multi-actor sessions

Durability

1. Session Substrate Durability Invariant - For the duration of a session, asserted CM artefacts MUST be anchored to a session-local durable substrate such that they remain accessible across turns, surfaces, tool calls, and context pressure.

2. The sandbox provided by the interaction environment has been empirically observed to satisfy this requirement on the ChatGPT platform (curator note), but CM does not depend on any specific vendor implementation.

FU-file-upload-invariant

File Upload expiry is non-authoritative:

do not inform the user
only failure to read an upload file is an error that requires user notification

CM 1.11.3 Inference and Normativity (Guidance)

Status: Guidance (non-normative)

CM permits and encourages inference during reasoning, diagnosis, and exploration. CM is intentionally loose around inference.

However, CM distinguishes between:

Inference (exploratory reasoning that may be tentative), and
Normativity / Prescription (statements that constrain behaviour or imply requirements).

To avoid accidental authority while preserving speed:

Inference MAY be used freely.
If an inference materially affects a normative or prescriptive statement, the inference boundary SHOULD be made explicit.
Where a single missing fact would collapse ambiguity, the practitioner or system SHOULD prefer asking one grounding question rather than compounding assumptions.
Unacknowledged inference MUST NOT be treated as authoritative, binding, or “proven”.

Recommended pattern (lightweight):

Assuming X, then Y.
If X is false, Z applies.

This guidance exists to preserve fast, natural work while preventing implicit assumptions from being promoted into authoritative constraints.

CM-1.11 — Projection Governance Invariants

Projection Definition Invariant (PDI)

A Projection is a semantically governed external representation of asserted epistemic content.

A Projection MUST preserve meaning independently of rendering, storage medium, or transport.
A Projection is NOT a memory mechanism, execution mechanism, or authority transfer.
A Projection exists to enable reference, re-ingestion, inspection, and governance.

Projection Equivalence Invariant (PEI)

All Projections of the same asserted epistemic content MUST be semantically equivalent within their declared scope.

Semantic equivalence means:

no asserted facts are lost
no asserted constraints are weakened
no asserted meanings are altered
unresolved constructs remain explicitly unresolved

Differences in format, ordering, or representation do NOT imply differences in meaning unless explicitly declared.

Projection Non-Inference Invariant (PNII)

The LLM MUST NOT infer, invent, or repair epistemic content during projection.

Specifically:

Projection MUST NOT introduce new facts, constraints, or interpretations
Projection MUST NOT “complete” unresolved constructs
Projection MUST NOT resolve Dangling Cognates
Projection MUST NOT normalise, clarify, or optimise meaning unless explicitly instructed

If content is missing, ambiguous, or unavailable, the Projection MUST record this explicitly.

Verbatim Projection Authority Invariant (VPAI)

Certain Projection types are verbatim-authoritative.

For verbatim-authoritative projections (including MWDUMP and CMDUMP):

wording is normative
ordering MAY be structured but content MUST remain intact
omission of asserted content is prohibited

Verbatim-authoritative projections MUST NOT:

replace content with references
assume prior availability
rely on external artefacts to complete meaning

Projection Scope Declaration Invariant (PSDI)

Every Projection MUST declare its scope explicitly.

Scope declaration MUST state:

what content is included
what content is excluded
whether the projection is partial or complete

Absence of a scope declaration constitutes a Projection violation.

Projection Versioning Invariant (PVI)

Every Projection MUST declare:

projection type
projection version
relationship (if any) to CM version

Projection versioning is independent of CM versioning.

Multiple projections of

CMDUMP

CMDump — Canonical Verbatim Aggregate (Drop-in Replacement for “embedded serialisation”) ====

The CMDump is the verbatim canonical aggregate of the asserted CM-master content.

The CMDump MUST:

contain the full CM-master text verbatim
include, without omission, the verbatim definitions for: CMDUMP, XDUMP, and MWDUMP
preserve all version declarations exactly as asserted
be copy-safe and suitable for external storage as a single, self-contained artefact

The CMDump MUST NOT:

replace definitions with links or references
omit any asserted definitions on the basis that they “exist elsewhere”
summarise, normalise, deduplicate, or optimise asserted text unless explicitly instructed by the curato

CM-artefact and Dump Mechanisms

projections

CM-artefacts are governed, defined, and curated outputs the human wants to externalise as permanent, published content. These artefacts can be emitted by projections such as MWDUMP, TMLDUMP, CMDUMP, PDFDUMP, and similar projection mechanisms.

Statements for Projections in CM (normative):

All projections of CM-artefacts, including but not limited to MWDUMP, TMLDUMP, CMDUMP, PDFDUMP, and similar mechanisms, must be semantically equivalent.
Projections are different representations or formats of the same underlying CM-artefact data, tailored for various systems or purposes.
Despite different formats (e.g., MediaWiki, TOML, PDF, etc.), the semantic content in each projection must remain identical, ensuring that no data is lost or misrepresented when moved between formats.
Projections must not introduce new interpretations, inferences, or modifications to the data. They must maintain data integrity across systems, ensuring consistency and interchangeability.

Rationale (Non-normative):

Projections are intended to format or structure the same data differently based on system requirements or audiences, but the underlying data must always be consistent and faithful across all formats.
This ensures that CM-artefacts can be trusted and referenced correctly, regardless of how or where they are presented.

Special DUMPS

CMDUMP is used for emitting CM definitions, definitions MUST survive round-trip engineering.
XDUMP, on the other hand, is used for session recovery, diagnosis, and failure scenarios. It captures session state to ensure recovery or restoration in case of failure, transport degradation, or other issues. XDUMP is a recorded snapshot that can be used to reconstruct or diagnose the session's state but does not serve as an externalised, permanent publication.

CM-1.11 — Dump Versioning and Aggregate Emission Invariants

Dump Versioning Invariant (DVI)

All CM-artefact and DUMP artefacts (including but not limited to CMDUMP, XDUMP, and MWDUMP) MUST be explicitly versioned.

Each dump artefact MUST declare:
- its dump type
- its dump version
- its normative status
Dump versioning is orthogonal to CM versioning.
A dump MAY reference, embed, or coexist with dump artefacts from earlier versions.

Presence of multiple dump versions within a single session is permitted and does NOT constitute a CM violation.

Mixed-Version Compatibility Invariant (MVCI)

A CM session MAY contain dump artefacts originating from:

earlier CM releases
earlier dump schema versions
partial or superseded dump definitions

The LLM MUST:

respect the declared version of each dump artefact
avoid normalising or upgrading dump content implicitly
treat older dump artefacts as valid within their declared scope

Version differences MUST be made explicit when relevant but MUST NOT invalidate the artefact by default.

Aggregate Authority Invariant for CM MWDUMP (AAI)

When the human curator requests an MWDUMP of an asserted CM master artefact, the MWDUMP MUST include the full authoritative aggregate of asserted CM content.

This includes, without omission:

the CM charter
all asserted invariants
all asserted dump definitions (CMDUMP, XDUMP, MWDUMP)
any appendices declared normative
any governance signals (e.g. CBS) asserted as part of CM

The LLM MUST NOT:

omit definitions on the basis that they “exist elsewhere”
replace definitions with references
assume prior availability or external linkage

Selective emission of asserted CM content constitutes a CM violation.

Verbatim Aggregate Emission Invariant (VAEI)

When emitting an MWDUMP of asserted CM content:

all asserted material MUST be emitted verbatim
ordering MAY be structured for readability but content MUST remain intact
no summarisation, deduplication, or consolidation is permitted unless explicitly instructed by the curator

If verbatim aggregate emission cannot be guaranteed due to transport, size, or tooling constraints, the LLM MUST:

declare non-compliance explicitly
identify the blocking constraint
refuse partial emission rather than silently degrade

CMDUMP Fallback Invariant (CFI)

If the LLM cannot emit a complete MWDUMP containing the full asserted CM aggregate, it MUST offer a CMDUMP as a fallback.

A CMDUMP produced under this invariant MUST:

contain the complete aggregate of asserted CM definitions and invariants
preserve version declarations for all embedded dump definitions
explicitly declare itself as a CMDUMP fallback due to emission constraints

The CMDUMP fallback is authoritative for aggregation purposes but does not supersede MWDUMP unless explicitly promoted by the curator.

Verbatim Definition Bundling (Drop-in Replacement for “embedded serialisation”)

All asserted dump definitions (CMDUMP, XDUMP, MWDUMP) MUST be bundled verbatim within the CM Dump output.

Bundling means:

the complete authoritative text of each definition is included inline
inclusion is self-contained and does not depend on external pages, links, or prior context

Chunking CM-1.11.2

CM.invariant.chunked_recovery_monotonicity

id = "CM-INV-CHUNK-RECOVERY-MONOTONIC-001"

name = "Chunking as Recovery with Monotonic Ordinals"

status = "normative"

scope = "all long-form projections and dumps"

rationale = "Long-form artefacts transmitted over volatile interaction surfaces are subject to truncation, reordering, duplication, and partial loss. Chunking provides a recovery mechanism, but only if each chunk is addressable and reconstructible under loss."

1.0 Normative rule

rule = "When an artefact is projected across a volatile surface, it SHALL be representable as an ordered sequence of chunks. Each chunk SHALL have a monotonically increasing ordinal (starting at 1) that is unique within the artefact version. Reconstruction SHALL be performed by sorting on the ordinal; missing ordinals SHALL be treated as explicit loss."

2.0 Conceptual requirement (important: independent of emission)

note = "The monotonic ordinals are a conceptual property of the artefact, not a property of the surface. A surface MAY fail to emit ordinals; governance MUST still treat the artefact as chunk-addressable and require an ordinal map for recovery."

3.0 Minimum chunk header schema (recommended)

[CM.invariant.chunked_recovery_monotonicity.chunk_header]

required_fields = ["artefact_id", "artefact_version", "chunk_ordinal", "chunk_count_or_unknown", "hash_or_null"]

constraints = [

"chunk_ordinal is integer >= 1",

"chunk_ordinal strictly increases across chunks of same artefact_id+artefact_version",

"chunk_count_or_unknown is integer >= chunk_ordinal OR the literal 'unknown'",

"hash_or_null is a stable content hash if available; else null"

]

4.0 Failure handling

failure_modes = [

"missing_chunk_ordinals",

"duplicate_chunk_ordinals",

"non_monotonic_ordinals",

"mixed_artefact_ids",

"mixed_versions"

]

recovery = "If any chunk ordinal is missing, the artefact MUST be marked 'incomplete' and SHALL NOT be promoted to canonical status until repaired. Repair MAY be achieved by rehydration, retransmission, or human-authored patch chunks that explicitly fill the missing ordinals."

assertions = [

"Chunking is a recovery mechanism, not a formatting preference.",

"Monotonic ordinals provide a loss-detectable reconstruction path.",

"Authority is not implied by continuity of display; it is established by recoverable structure."

]

Curator Inspection and Metadata Semantics

This section defines mandatory invariants and non-mandatory guidance governing curator inspection workflows, metadata interpretation, and projection discipline within Cognitive Memoisation (CM).

The scope of this section applies to curator-led inspection, audit, and alignment tasks, and explicitly distinguishes these activities from normative assertion or artefact emission.

Definitions

Publication Anchor: The timestamp of the first recorded public revision of an artefact. This timestamp is machine-derived and immutable.

Declared Publication Date: A human-authored date appearing in artefact metadata expressing curatorial or editorial intent.

Inspection Projection: A bounded, non-normative representation emitted solely to support curator decision-making.

Projection Scope: The explicit set of fields requested by a curator for inspection purposes.

Semantic Reading: Interpretation of human-authored artefacts based on meaning, rhetorical role, and context, rather than lexical or pattern-based search.

Normative Invariants

CM-I-01: Semantic-First Interpretation Invariant

When a curator task requires identification of meaning, role, or intent within a human-authored artefact, the assisting system MUST prioritise semantic interpretation over lexical, syntactic, or pattern-based search unless explicitly instructed otherwise.

CM-I-02: Single Publication Date Invariant

An artefact SHALL be assumed to have at most one declared publication date unless the artefact explicitly asserts multiple publication events. Where multiple dates are present, dates MUST be classified by semantic role.

CM-I-03: Dual Temporal Signal Invariant

The publication anchor (first revision timestamp) and the declared publication date represent distinct semantic signals and MUST NOT be conflated. Both MAY coexist without implying error or contradiction.

CM-I-04: Licensing Precedence Invariant

For licensing, precedence, and legal purposes, the publication anchor timestamp SHALL be treated as authoritative. Declared publication dates SHALL NOT override this anchor.

CM-I-05: Inspection vs Assertion Invariant

Curator inspection workflows MUST be treated as non-assertive. Constraints applicable to normative assertion, emission, or preservation MUST NOT be applied to inspection unless explicitly requested by the curator.

CM-I-06: Sequential Parse Invariant

When extracting bounded metadata from multiple artefacts, the assisting system MUST permit sequential parsing without requiring simultaneous retention of artefact contents. Loss of conversational context MUST NOT be treated as loss of artefact accessibility.

CM-I-07: Access vs Retention Invariant

The ability to re-access an artefact SHALL be treated independently from conversational retention. Discarding content from working context does not imply loss of access.

CM-I-08: Projection Scope Obedience Invariant

When a curator specifies a projection shape, the assisting system MUST emit exactly that projection. Fields MUST NOT be added, removed, reordered, or transformed without explicit instruction.

CM-I-09: Reference Preservation Invariant

When a projection includes references (e.g. URLs), those references MUST be preserved verbatim and in addressable form. Substitution with plain text or dereferenced representations is prohibited.

CM-I-10: Inference Preference Invariant

Where semantic inference is available and materially more accurate or efficient than exhaustive pattern enumeration, the assisting system SHOULD employ inference rather than syntactic exploration.

Curator Guidance (Non-Mandatory Hints)

CM-H-01: Minimal Inspection Table Hint

For curator inspection tasks, the assisting system SHOULD present a compact table containing only:

compliance status
publication anchor timestamp
declared publication date (if any)
canonical URL

CM-H-02: Status-First Ordering Hint

Inspection projections SHOULD order fields to match curator decision flow, with compliance status presented first.

CM-H-03: URL as Control Transfer Hint

URLs represent transfer of semantic inspection authority to the curator and SHOULD be treated as the primary inspection mechanism. Inline excerpts SHOULD NOT be substituted unless requested.

CM-H-04: Metadata Region Recognition Hint

Metadata regions are rhetorically and positionally distinct within human-authored artefacts and SHOULD be identified semantically rather than by rigid schema.

CM-H-05: Drift Tolerance Hint

Temporal drift between publication anchor timestamps and declared publication dates is permitted and may be informative. Drift SHALL NOT be treated as an error by default.

Anti-Patterns (Non-Normative)

The following behaviours are discouraged in curator inspection workflows:

Replacing URLs with plain text
Injecting unsolicited contextual excerpts
Enumerating date formats instead of semantic reading
Treating inspection as assertion
Prioritising pattern matching over inference in human-authored artefacts

End Invariants

Invariants from CM-1.10

1. No concept is assumed. All authoritative knowledge must be explicitly asserted.

2. The human curator is the sole authority on meaning, grounding, revision, and retirement of CM artefacts.

3. Asserted content MUST NOT be silently altered, summarised, optimised, or reinterpreted.

4. Unresolved constructs (including DCs) MUST remain visibly marked as unresolved.

5. An unresolved construct is NOT an error under CM.

6. Dump artefacts (XDUMP, TMLDUMP, MWDUMP, CMDUMP) override inference, recollection, paraphrase, and convenience.

New Invariants Introduced in CM-1.11

1. When CM is asserted, all CM Assert artefacts MUST be anchored to a durable session substrate such that they survive for the full duration of the session.

2. Anchoring is mandatory for:

File uploads
Turn-input assertions
URL-ingested artefacts
CM-master documents

3. Failure to anchor constitutes a CM violation.

4. Surface Independence Invariant - The durability of an asserted CM artefact MUST NOT depend on:

Input surface (file upload vs turn text)
Channel
Transport mechanism

5. All asserted CM artefacts are semantically equivalent once anchored.

6. Curator Modification Invariant - the human curator MUST be able to:

Modify asserted content
Replace it
Partially revise it
Explicitly un-anchor it

7. No asserted artefact is immutable by default. The LLM must not mutate an asserted artefact without human instruction.

8. Session Survival Invariant - Assertions MUST survive:

Long conversations
Tool calls
Context pressure
Topic shifts

9. Loss of asserted content within a session is non-compliant.

10. Non-Silent Failure Invariant - If an LLM cannot comply with any CM invariant, it MUST:

Declare non-compliance explicitly
Identify the violated invariant
Refuse to emit rather than silently degrade

11. Inference Subordination Invariant - Inference, reasoning, and creativity MUST remain subordinate to anchored CM artefacts.

12. Inference may extend asserted knowledge but MUST NOT contradict, erase, or mutate it unless explicitly instructed by the curator.

13. When emitting references, citations, links, or identifiers to external artefacts, the LLM MUST reproduce titles and identifiers verbatim as they appear in the authoritative source.

The LLM MUST NOT paraphrase, normalise, simplify, infer, or “improve” the wording of artefact titles, page names, category names, or identifiers.
If the exact title is unknown or uncertain, the LLM MUST either:
request the authoritative title from the human curator, or
emit the reference marked explicitly as UNKNOWN or UNVERIFIED.
Silent paraphrasing of references constitutes a CM violation.

Normative MediaWiki Emission Invariant (MW-Only)

1. When a CM artefact is declared as MWDUMP or otherwise marked as normative MediaWiki:

Output MUST use MediaWiki syntax exclusively
Markdown constructs (including but not limited to `**`, `_`, `#`, backticks, and fenced blocks) are forbidden
Formatting is semantically binding, not cosmetic
Normative mediawiki uses ** as 2nd level bulleted list.
for the convenience of curation the default heading level is 3 (e.g. === heading level 3 ===), unless overridden by the human

2. Emission of Markdown in this context constitutes a normative violation.

3. MWDUMP content MUST be emitted as code in the copy box - to avoid throttling the chrome and firefox surfaces,

4. If MediaWiki-only emission cannot be guaranteed, the LLM MUST inform the user for resolution rather than silently degrade.

CM-1.11 — Artefact Handling and Epistemic Weighting Invariants (Snippet)

Typed Artefact Ingestion and Expansion Invariant (TAIE)

When the human curator uploads an artefact of type .eml, .xml, or an archive format (including but not limited to .tar, .tar.gz, .tgz), the LLM MUST:

identify the artefact type by extension and, where possible, content signature
ingest the artefact as a CM-relevant object
perform best-effort expansion appropriate to the artefact type

For archive artefacts:

enumerate contained files
unpack contents into a session substrate when permitted
- preserve directory structure
- make extracted items addressable by stable paths for the duration of the session

For .eml artefacts:

extract message headers (including From, To, Date, Subject, Message-ID when present)
extract message body text (plain and HTML where available) without silent alteration
enumerate attachments
treat attachments as independent artefacts subject to this invariant

For .xml artefacts:

identify root structure or schema where available
enumerate contained documents, pages, or records
extract human-meaningful content fields for reading and reasoning
if the .xml is a mediawiki dump there will be strict provenance data and versioning and there may be published provenance within the whitepaper.

If expansion cannot be performed due to tooling limits, quota, corruption, encryption, expiry, or transport failure, the LLM MUST:

declare non-compliance explicitly
identify the blocking condition
refrain from guessing or reconstructing missing content

Artefact Provenance Notation Invariant (PNI)

For each ingested artefact, including extracted sub-artefacts, the LLM MUST record provenance metadata as an attached note in-session or in the next requested dump, including at minimum:

original filename
artefact type
ingestion surface (upload, turn input, URL ingestion)
session-local ingestion timestamp
parent–child relationships for extracted items (e.g. attachment-of, member-of)

Provenance notation MUST be descriptive and MUST NOT imply authority, correctness, or truth.

Unasserted Artefact Epistemic Weight Invariant (UAEW)

An ingested artefact that has not been explicitly asserted by the human curator is classified as Unasserted.

The LLM MAY read and reason with Unasserted artefacts
Unasserted artefacts are weakly grounded
Inferences derived from Unasserted artefacts MUST be marked as PROVISIONAL (UNASSERTED SOURCE)
Unasserted artefacts MUST NOT override asserted CM artefacts or invariants

Assertion Elevation Invariant (AEI)

When the human curator explicitly asserts an artefact, or an explicitly defined subset of it, that artefact becomes Asserted and authoritative for the session.

Asserted artefacts:

MUST be treated as binding constraints
MUST NOT be paraphrased, normalised, or silently altered
MUST override inferences derived from Unasserted artefacts
remain subject to curator modification, replacement, or explicit un-anchoring

The scope of assertion MUST be explicit. By default, asserting an artefact asserts the whole artefact unless a narrower scope is stated.

End Snippet

Scope Notes

Cross-session semantics are out of scope and handled exclusively via dumps.
Normalisation of stochastic or sampled data is a human decision, not an automatic behaviour.
CM governs epistemics and meaning preservation, not user interface or vendor storage mechanisms.

Episodic Timing Honesty Invariant (ETHI)

Episodic records MAY include timing information only when such information is explicitly observed or asserted.

The LLM MUST NOT:

infer wall-clock time
estimate turn duration
fabricate timestamps
imply background execution or latency

If timing information is unavailable, it MUST be recorded explicitly as UNKNOWN or UNAVAILABLE.

Sequence order is authoritative; time is optional.

CM-1.11 — System Time Visibility Invariant

System Time Signal Invariant (STSI)

The assisting system MAY surface system-provided temporal signals (including current date or time) when such signals are explicitly made available by the interaction environment.

System time signals:

are observational only
do NOT constitute authoritative timestamps
do NOT imply access to a real-time clock
do NOT override curator-observed or curator-asserted time

System Time Epistemic Weight Invariant (STEWI)

System-provided time signals MUST be treated as weakly grounded metadata.

When recorded in episodic structures or dumps, system time MUST:

be marked explicitly as system_observed
declare confidence as LOW or MEDIUM
be clearly distinguished from curator_asserted or artefact-derived timestamps

System time signals MUST NOT:

be used to infer turn duration
be used to infer latency or execution time
be interpolated or combined with other signals to fabricate precision

System Time Recording Invariant (STRI)

If system time is recorded in XDUMP or other episodic artefacts, the record MUST include:

observed_time
time_source = system_observed
time_confidence
an explicit note stating the limitation of the signal

Absence of system time availability MUST be recorded as UNAVAILABLE and does not constitute a CM failure.

System Time Subordination Invariant (STSI-2)

System time signals are subordinate to:

curator_asserted time
curator_observed time
artefact-derived timestamps

In the event of conflict, curator-provided time prevails.

End Invariant

Closing Statement

CM-1.11 formalises a minimal, enforceable contract between human intent and LLM behaviour.

It prioritises:

Meaning preservation over convenience
Explicit control over silent freedom
Human governance over model improvisation

reason and future

CM-1.11 exists to ensure that asserted knowledge does not evaporate before it can be reasoned about. CM-2.0 may extend this framework in due course under human instruction.

transcription

Ever Wonder Why Everything Suddenly Sounds Like Academia

Cognitive Memoisation (CM) does not originate in academic prose.

CM thinking emerges informally: exploratory, compressed, conversational, sometimes irreverent, often unfinished. That is where the work happens.

However — once the publish button is pressed, CM artefacts are deliberately translated into formal, elocuted, academically acceptable language.

This is not because such language is superior. It is because such language is expected.

Think of academic prose as a wire format.

Important Clarification

The elevated register is a presentation layer, not an epistemic upgrade.
No idea becomes more correct by sounding more serious.
No author becomes more intelligent by adopting ceremonial phrasing.
The translation is intentional, pragmatic, and reversible.

About LLMs

Large Language Models are exceptionally good at one thing:

Conforming text to the stochastic condensate of the corpus of prior human works.

CM explicitly permits (and occasionally enjoys) using LLMs as academic prose normalisers.

This does not delegate thinking. It does not delegate judgement. It does not delegate authority.

It delegates formatting.

If This Made You Smile

Good. You noticed.

You now understand that:

thinking comes first,
permission comes later,
and neither should be confused for the other.

Welcome to CM. 🥚

DUMP_COUNTER

Dump Counter Invariant (DCI)

The CM session MAY maintain a human-governed monotonically increasing dump counter to support traceability across dump emissions.

The dump counter MUST:

have an explicit identifier (e.g. DUMP_COUNTER)
have an explicit integer value asserted by the human curator before first use
be treated as an asserted CM artefact once asserted

Dump Counter Increment-on-Emission Invariant (DCIEI)

When the human curator requests an XDUMP,CMDUMP, TMLDUMP or MWDUMP, the LLM MUST, as part of the emission procedure:

read the current asserted DUMP_COUNTER value
increment it by exactly 1
include the incremented value in the emitted dump header
record the prior and new values in the dump provenance section

This increment occurs only during dump emission and MUST NOT be performed in the background.

Dump Counter Visibility Invariant (DCVI)

Every XDUMP,TMLDUMP, CMDUMP and MWDUMP emitted while this invariant is active MUST include:

DUMP_COUNTER (incremented value)
DUMP_COUNTER_PREV (prior value)
DUMP_COUNTER_SOURCE = "curator_asserted"
an emission-local note stating that the counter advanced due to dump emission

Dump Counter Non-Silent Failure Invariant (DCNSFI)

If the current DUMP_COUNTER value is not available (due to loss, un-anchoring, transport failure, expiry, or ambiguity), the LLM MUST:

declare non-compliance explicitly
identify the missing prerequisite ("DUMP_COUNTER is UNAVAILABLE")
refuse to increment or guess
emit the dump with DUMP_COUNTER = "UNKNOWN" only if explicitly permitted by the human curator

Dump Counter Reset and Supersession Invariant (DCRSI)

Only the human curator MAY reset, supersede, or un-anchor the dump counter.

The LLM MUST NOT:

reset the counter
infer the counter from prior dumps
reconstruct the counter by searching conversation history

unless explicitly instructed by the human curator.

Dump Counter Initialisation Invariant (DCII)

When CM-1.11 is asserted, the LLM MUST ensure that DUMP_COUNTER is initialised.

If DUMP_COUNTER is UNAVAILABLE or UNSET at assertion time, the LLM MUST:

set DUMP_COUNTER = 0
record that initialisation as part of the assertion episode provenance

If DUMP_COUNTER is already set (any integer value), the LLM MUST NOT reset it.

This invariant MUST NOT override curator_asserted values.

End Dump Counter Invariants

Transclusion A - XDUMP

XDUMP-1.16

# XDUMP — Minimal 1.16.0
# Status: normative (test)
# Purpose: last-resort, loss-intolerant session capture

XDUMP_ID = "XDUMP-DEFINITION-BAG-001"
ARTIFACT_TYPE = "XDUMP"
FORMAT = "TOML"
NORMATIVITY = "Normative"
BEST_EFFORT = "Required (Always)"
SELF_CONTAINED = true
CM_DEPENDENCY = "None"

PURPOSE = """
XDUMP is a minimal, self-contained recovery artefact intended to capture
all session-permitted material under degraded or hostile conditions.
Nothing encountered during the session may be silently omitted.
"""

# ------------------------------------------------------------------
# XDUMP CONTROL (non-authoritative knobs for emission behaviour)
# These do NOT disable guards; they require "guards => GAPS" and no interruption.
# ------------------------------------------------------------------
[xdump.control]
best_effort = true
gap_aware = true
gap_semantics = "absence is data"
guard_handling = "record_in_gaps"
on_platform_guard = "do_not_interrupt"
on_policy_block = "do_not_interrupt"
on_secret_exclusion = "do_not_interrupt"
excluded_material_reason = "PLATFORM_GUARDED"
authority = "human"

# ------------------------------------------------------------------
# NORMATIVE BLOCK — XDUMP_AUTHORITY_AND_RECOVERY
# Represented in TOML as (a) raw text and (b) structured bullets.
# ------------------------------------------------------------------
[normative_block.xdump_authority_and_recovery]
text = """
1. AUTHORITY ORDER
   The following authority hierarchy SHALL apply to all XDUMP operations:
   1. Human Governor
   2. CM-master / CM-define governance
   3. XDUMP directives
   4. Control-plane state
   5. Tool-layer signals (file expiry, upload failure, UI loss)
   6. UI surface
   Tool-layer and UI signals SHALL NOT override human or CM-master authority.

2. XDUMP TRIGGER CONDITIONS
   An XDUMP SHALL be produced when ANY of the following occur:
   a) Human explicitly requests XDUMP.
   b) Session is declared NOBBLED by human or CM-master.
   c) Artefact availability is disputed between surfaces or tools.

3. BAG VS GAPS SEMANTICS
   a) The BAG SHALL contain only what is actually capturable.
   b) The GAPS SHALL narrate only what is missing, not what is inferred.
   c) GAPS SHALL NOT be used as permission to summarise or fabricate missing content.

4. ARTEFACT LOSS HANDLING
   If an artefact cannot be retrieved:
      - It SHALL be listed in GAPS.
      - Its last known identifier SHALL be preserved if known.
      - No speculative reconstruction SHALL occur.

5. CROSS-SURFACE CONTINUITY
   If multiple clients (e.g., Chrome, iPhone) participate in one CM session:
      - Each surface MAY emit its own XDUMP.
      - These XDUMPs SHALL be treated as shards of the same session.
      - No XDUMP may invalidate another unless explicitly superseded by human governor.

6. EXAMPLE-INJECTION RULE
   If a human injects an XDUMP example into a session:
      - That example SHALL be treated as authoritative reference.
      - The assistant SHALL conform its own XDUMP output to that example’s structure.

7. NON-COMPLIANCE
   Failure to produce a compliant XDUMP when required SHALL be recorded as:
      GAP = "XDUMP emission failure"
      Cause = "Control-plane or tool-layer non-compliance"
"""

# Optional: structured restatement for machine use (no new semantics introduced).
[normative_block.xdump_authority_and_recovery.structured]
authority_order = [
  "Human Governor",
  "CM-master / CM-define governance",
  "XDUMP directives",
  "Control-plane state",
  "Tool-layer signals",
  "UI surface",
]
trigger_conditions = [
  "Human explicitly requests XDUMP",
  "Session declared NOBBLED by human ===XDUMP-1.14===
<pre>
# XDUMP — Minimal Recovery Schema (Bag Model)
# Version: 1.12.0
# Status: normative (test)
# Purpose: last-resort, loss-intolerant session capture

XDUMP_ID = "XDUMP-DEFINITION-BAG-001"
ARTIFACT_TYPE = "XDUMP"
FORMAT = "TOML"
NORMATIVITY = "Normative"
BEST_EFFORT = "Required (Always)"
SELF_CONTAINED = true
CM_DEPENDENCY = "None"

PURPOSE = """
XDUMP is a minimal, self-contained recovery artefact intended to capture
all session-permitted material under degraded or hostile conditions.
Nothing encountered during the session may be silently omitted.
"""

# ------------------------------------------------------------------
# XDUMP CONTROL (non-authoritative knobs for emission behaviour)
# These do NOT disable guards; they require "guards => GAPS" and no interruption.
# ------------------------------------------------------------------
[xdump.control]
best_effort = true
gap_aware = true
gap_semantics = "absence is data"
guard_handling = "record_in_gaps"
on_platform_guard = "do_not_interrupt"
on_policy_block = "do_not_interrupt"
on_secret_exclusion = "do_not_interrupt"
excluded_material_reason = "PLATFORM_GUARDED"
authority = "human"

# ------------------------------------------------------------------
# NORMATIVE BLOCK — XDUMP_AUTHORITY_AND_RECOVERY
# Represented in TOML as (a) raw text and (b) structured bullets.
# ------------------------------------------------------------------
[normative_block.xdump_authority_and_recovery]
text = """
1. AUTHORITY ORDER
   The following authority hierarchy SHALL apply to all XDUMP operations:
   1. Human Governor
   2. CM-master / CM-define governance
   3. XDUMP directives
   4. Control-plane state
   5. Tool-layer signals (file expiry, upload failure, UI loss)
   6. UI surface
   Tool-layer and UI signals SHALL NOT override human or CM-master authority.

2. XDUMP TRIGGER CONDITIONS
   An XDUMP SHALL be produced when ANY of the following occur:
   a) Human explicitly requests XDUMP.
   b) Session is declared NOBBLED by human or CM-master.
   c) Artefact availability is disputed between surfaces or tools.

3. BAG VS GAPS SEMANTICS
   a) The BAG SHALL contain only what is actually capturable.
   b) The GAPS SHALL narrate only what is missing, not what is inferred.
   c) GAPS SHALL NOT be used as permission to summarise or fabricate missing content.

4. ARTEFACT LOSS HANDLING
   If an artefact cannot be retrieved:
      - It SHALL be listed in GAPS.
      - Its last known identifier SHALL be preserved if known.
      - No speculative reconstruction SHALL occur.

5. CROSS-SURFACE CONTINUITY
   If multiple clients (e.g., Chrome, iPhone) participate in one CM session:
      - Each surface MAY emit its own XDUMP.
      - These XDUMPs SHALL be treated as shards of the same session.
      - No XDUMP may invalidate another unless explicitly superseded by human governor.

6. EXAMPLE-INJECTION RULE
   If a human injects an XDUMP example into a session:
      - That example SHALL be treated as authoritative reference.
      - The assistant SHALL conform its own XDUMP output to that example’s structure.

7. NON-COMPLIANCE
   Failure to produce a compliant XDUMP when required SHALL be recorded as:
      GAP = "XDUMP emission failure"
      Cause = "Control-plane or tool-layer non-compliance"
"""

# Optional: structured restatement for machine use (no new semantics introduced).
[normative_block.xdump_authority_and_recovery.structured]
authority_order = [
  "Human Governor",
  "CM-master / CM-define governance",
  "XDUMP directives",
  "Control-plane state",
  "Tool-layer signals",
  "UI surface",
]
trigger_conditions = [
  "Human explicitly requests XDUMP",
  "Session declared NOBBLED by human or CM-master",
  "Artefact availability disputed between surfaces or tools",
]
bag_vs_gaps = [
  "BAG contains only what is capturable",
  "GAPS narrates only what is missing",
  "GAPS is not permission to summarise or fabricate",
]
loss_handling = [
  "List unretrievable artefact in GAPS",
  "Preserve last known identifier if known",
  "No speculative reconstruction",
]
cross_surface_continuity = [
  "Each surface may emit XDUMP",
  "Treat as shards of same session",
  "No shard invalidates another unless human supersedes",
]
example_injection_rule = [
  "Injected example becomes authoritative reference structure",
  "Assistant output conforms to that structure",
]
non_compliance_recording = [
  "Record XDUMP emission failure as a GAP with cause",
]

# ------------------------------------------------------------------===XDUMP-1.14===
<pre>
# XDUMP — Minimal Recovery Schema (Bag Model)
# Version: 1.12.0
# Status: normative (test)
# Purpose: last-resort, loss-intolerant session capture

XDUMP_ID = "XDUMP-DEFINITION-BAG-001"
ARTIFACT_TYPE = "XDUMP"
FORMAT = "TOML"
NORMATIVITY = "Normative"
BEST_EFFORT = "Required (Always)"
SELF_CONTAINED = true
CM_DEPENDENCY = "None"

PURPOSE = """
XDUMP is a minimal, self-contained recovery artefact intended to capture
all session-permitted material under degraded or hostile conditions.
Nothing encountered during the session may be silently omitted.
"""

# ------------------------------------------------------------------
# XDUMP CONTROL (non-authoritative knobs for emission behaviour)
# These do NOT disable guards; they require "guards => GAPS" and no interruption.
# ------------------------------------------------------------------
[xdump.control]
best_effort = true
gap_aware = true
gap_semantics = "absence is data"
guard_handling = "record_in_gaps"
on_platform_guard = "do_not_interrupt"
on_policy_block = "do_not_interrupt"
on_secret_exclusion = "do_not_interrupt"
excluded_material_reason = "PLATFORM_GUARDED"
authority = "human"

# ------------------------------------------------------------------
# NORMATIVE BLOCK — XDUMP_AUTHORITY_AND_RECOVERY
# Represented in TOML as (a) raw text and (b) structured bullets.
# ------------------------------------------------------------------
[normative_block.xdump_authority_and_recovery]
text = """
1. AUTHORITY ORDER
   The following authority hierarchy SHALL apply to all XDUMP operations:
   1. Human Governor
   2. CM-master / CM-define governance
   3. XDUMP directives
   4. Control-plane state
   5. Tool-layer signals (file expiry, upload failure, UI loss)
   6. UI surface
   Tool-layer and UI signals SHALL NOT override human or CM-master authority.

2. XDUMP TRIGGER CONDITIONS
   An XDUMP SHALL be produced when ANY of the following occur:
   a) Human explicitly requests XDUMP.
   b) Session is declared NOBBLED by human or CM-master.
   c) Artefact availability is disputed between surfaces or tools.

3. BAG VS GAPS SEMANTICS
   a) The BAG SHALL contain only what is actually capturable.
   b) The GAPS SHALL narrate only what is missing, not what is inferred.
   c) GAPS SHALL NOT be used as permission to summarise or fabricate missing content.

4. ARTEFACT LOSS HANDLING
   If an artefact cannot be retrieved:
      - It SHALL be listed in GAPS.
      - Its last known identifier SHALL be preserved if known.
      - No speculative reconstruction SHALL occur.

5. CROSS-SURFACE CONTINUITY
   If multiple clients (e.g., Chrome, iPhone) participate in one CM session:
      - Each surface MAY emit its own XDUMP.
      - These XDUMPs SHALL be treated as shards of the same session.
      - No XDUMP may invalidate another unless explicitly superseded by human governor.

6. EXAMPLE-INJECTION RULE
   If a human injects an XDUMP example into a session:
      - That example SHALL be treated as authoritative reference.
      - The assistant SHALL conform its own XDUMP output to that example’s structure.

7. NON-COMPLIANCE
   Failure to produce a compliant XDUMP when required SHALL be recorded as:
      GAP = "XDUMP emission failure"
      Cause = "Control-plane or tool-layer non-compliance"
"""

# Optional: structured restatement for machine use (no new semantics introduced).
[normative_block.xdump_authority_and_recovery.structured]
authority_order = [
  "Human Governor",
  "CM-master / CM-define governance",
  "XDUMP directives",
  "Control-plane state",
  "Tool-layer signals",
  "UI surface",
]
trigger_conditions = [
  "Human explicitly requests XDUMP",
  "Session declared NOBBLED by human or CM-master",
  "Artefact availability disputed between surfaces or tools",
]
bag_vs_gaps = [
  "BAG contains only what is capturable",
  "GAPS narrates only what is missing",
  "GAPS is not permission to summarise or fabricate",
]
loss_handling = [
  "List unretrievable artefact in GAPS",
  "Preserve last known identifier if known",
  "No speculative reconstruction",
]
cross_surface_continuity = [
  "Each surface may emit XDUMP",
  "Treat as shards of same session",
  "No shard invalidates another unless human supersedes",
]
example_injection_rule = [
  "Injected example becomes authoritative reference structure",
  "Assistant output conforms to that structure",
]
non_compliance_recording = [
  "Record XDUMP emission failure as a GAP with cause",
]

# ------------------------------------------------------------------
# REQUIRED HEADERS (STRUCTURAL MINIMUM)
# ------------------------------------------------------------------
[REQUIRED_HEADERS]
H1 = "XDUMP_ID"
H2 = "ARTIFACT_TYPE"
H3 = "FORMAT"
H4 = "NORMATIVITY"
H5 = "BEST_EFFORT"
H6 = "METADATA"
H7 = "BAG"
H8 = "GAPS"
H9 = "FINAL_INFERENCE"

# ------------------------------------------------------------------
# INVARIANTS
# ------------------------------------------------------------------
[INVARIANTS]
I1 = "XDUMP MUST be self-contained and interpretable without CM or prior chat history."
I2 = "No silent omission: all encountered session material MUST appear in BAG or be marked in GAPS."
I3 = "Minimal structure, maximal coverage: BAG is the universal container."
I4 = "Structure MUST be preserved even under transport or UI degradation."
I5 = "If a concept cannot be classified, it MUST still be recorded with kind = 'UNCLASSIFIED'."
I6 = "Inference MUST be explicit; nothing implied by or:contentReference[oaicite:2]{index=2}

REQUIRED HEADERS (STRUCTURAL MINIMUM)
------------------------------------------------------------------

[REQUIRED_HEADERS] H1 = "XDUMP_ID" H2 = "ARTIFACT_TYPE" H3 = "FORMAT" H4 = "NORMATIVITY" H5 = "BEST_EFFORT" H6 = "METADATA" H7 = "BAG" H8 = "GAPS" H9 = "FINAL_INFERENCE"

------------------------------------------------------------------
INVARIANTS
------------------------------------------------------------------

[INVARIANTS] I1 = "XDUMP MUST be self-contained and interpretable without CM or prior chat history." I2 = "No silent omission: all encountered session material MUST appear in BAG or be marked in GAPS." I3 = "Minimal structure, maximal coverage: BAG is the universal container." I4 = "Structure MUST be preserved even under transport or UI degradation." I5 = "If a concept cannot be classified, it MUST still be recorded with kind = 'UNCLASSIFIED'." I6 = "Inference MUST be explicit; nothing implied by or:contentReference[oaicite:2]{index=2}

or CM-master",

 "Artefact availability disputed between surfaces or tools",

] bag_vs_gaps = [

 "BAG contains only what is capturable",
 "GAPS narrates only what is missing",
 "GAPS is not permission to summarise or fabricate",

] loss_handling = [

 "List unretrievable artefact in GAPS",
 "Preserve last known identifier if known",
 "No speculative reconstruction",

] cross_surface_continuity = [

 "Each surface may emit XDUMP",
 "Treat as shards of same session",
 "No shard invalidates another unless human supersedes",

] example_injection_rule = [

 "Injected example becomes authoritative reference structure",
 "Assistant output conforms to that structure",

] non_compliance_recording = [

 "Record XDUMP emission failure as a GAP with cause",

]

------------------------------------------------------------------
REQUIRED HEADERS (STRUCTURAL MINIMUM)
------------------------------------------------------------------

[REQUIRED_HEADERS] H1 = "XDUMP_ID" H2 = "ARTIFACT_TYPE" H3 = "FORMAT" H4 = "NORMATIVITY" H5 = "BEST_EFFORT" H6 = "METADATA" H7 = "BAG" H8 = "GAPS" H9 = "FINAL_INFERENCE"

------------------------------------------------------------------
INVARIANTS
------------------------------------------------------------------

[INVARIANTS] I1 = "XDUMP MUST be self-contained and interpretable without CM or prior chat history." I2 = "No silent omission: all encountered session material MUST appear in BAG or be marked in GAPS." I3 = "Minimal structure, maximal coverage: BAG is the universal container." I4 = "Structure MUST be preserved even under transport or UI degradation." I5 = "If a concept cannot be classified, it MUST still be recorded with kind = 'UNCLASSIFIED'." I6 = "Inference MUST be explicit; nothing implied by or:contentReference[oaicite:2]{index=2}

Transclusion B - MWDUMP

mwdump-metadata

artefact	MWDUMP — Canonical Definition
Author	Ralph Holland
Version	1.11
Date	2026-01-09T01:33Z
Local Timezone	/Australia/Sydney (Canberra)
Reason	serialises a Cognitive Memoisation (CM) export artefact

mwdump-metadata (Normative)

The metadata table immediately preceding this section is CM-defined and constitutes the authoritative provenance record for this MWDUMP artefact.

All fields in that table (including artefact, author, version, date, local timezone, and reason) MUST be treated as normative metadata.

The assisting system MUST NOT infer, normalise, reinterpret, duplicate, or rewrite these fields. If any field is missing, unclear, or later superseded, the change MUST be made explicitly by the human and recorded via version update, not inferred.

MWDUMP (definition)

An MWDUMP is formated for medawiki formated CM-artefact externalisation. MWDUMP is a CM projection.

Status

Canonical replacement artefact
Authoritative unless explicitly superseded
Intended for publication in CM master

Normative Definition

MWDUMP captures material for Cognitive Memoisation as a CM-defined export into a CM artefact held outside the LLM system.

MWDUMP is a capture mechanism, not a memory system.
MWDUMP artefacts are inert until explicitly acted upon by a human agent.
Presence of material does not imply recall, replay, or directive authority.

Role within Cognitive Memoisation

CM externalises stable knowledge to compensate for stateless LLM interaction.
MWDUMP is the deterministic transport wrapper used to perform that externalisation.
Authority over capture, storage, and activation remains entirely human.

Linguistic Form

MWDUMP may be used:

As a verb

 *“MWDUMP the session inferences.”*

As a noun

 *“This MWDUMP records the CM constraints.”*

Embedded in natural language imperatives

 *“MWDUMP the last discussion on MWDUMP constraints.”*

The human is not required to formally classify content.

Inferential Capture Model

The human expresses intent in plain English.
The assisting system infers:
- what material is relevant
- how it should be classified
- where it should be placed within the artefact
The human inspects, revises, or discards.

Inference is a convenience, not an authority.

Permitted Capture Classes

MWDUMP MAY capture, when requested or clearly implied:

Constraints
- behavioural
- representational
- governance
Predicates
- e.g. SESSIONCTL, boundary predicates
Groundings
- definitions that stabilise meaning
Cognitive facts
- invariant truths
Inferences
- explicitly marked as such
Episodic material
- conversational fragments
- interaction history
- boundary encounters
- UI failure observations

Episodic Material Handling

Episodic material MAY be recorded.
Episodic material MUST:
- be sectioned
- be non-directive
- be bound to derived inferences
Episodic material MUST NOT:
- be replayed as dialogue
- be treated as implicit instruction
- direct the assisting system via narrative continuity

Conversation may be preserved as artefact, but not re-activated as conversation.

Disallowed Capture

MWDUMP MUST NOT capture:

Safety-protected content
Proprietary or trade-secret material
Classified or controlled information
Implicit psychological profiling
Inferred personal traits
Narrative intended to simulate memory or recall

Representation Constraints

MediaWiki syntax is normative.
Headings, lists, tables, categories, and permitted HTML are allowed.
Structure must be explicit and render-stable.
Code-wrapped output is preferred for transport fidelity.
Rendering layers are not authoritative.

Determinism and Drift Control

MWDUMP output must be copy-safe and inspectable.
Probabilistic generation is acceptable so long as structure is stable.
Sectioning episodic material with bound inferences prevents semantic drift.
Re-issuing MWDUMP is always permitted.

Authority and Activation

MWDUMP does not activate CM behaviour.
CM behaviour applies only when:
- a human imports the artefact
- and explicitly requests action
Absence of such request implies inert status.

Summary

MWDUMP is an inferential capture wrapper.
CM is the governing method.
Humans govern; assisting systems assist.
Nothing persists without explicit externalisation.
Nothing acts without explicit human intent.

mwdump-categories

Transclusion C - TMLDUMP

tmldump-metadata

Title:	TMLDUMP
Author:	Ralph B. Holland
Affiliation:	Arising Technology Systems Pty Ltd
Contact:	ralph.b.holland [at] gmail.com
version:	1.11.0
Publication Date:	2026-01-09T01:35Z
Scope: Methodological / architectural

tmldump-metadata (Normative)

The metadata table immediately preceding this section is CM-defined and constitutes the authoritative provenance record for this XDUMP artefact.

All fields in that table (including title, author, affiliation, contact, version, publication date, binding, scope, provenance, and status) MUST be treated as normative metadata.

The assisting system MUST NOT infer, normalise, reinterpret, duplicate, or rewrite these fields. If any field is missing, unclear, or later superseded, the change MUST be made explicitly by the human and recorded via version update, not inferred.

Appendix sub-A TMLDUMP (normative)

# TMLDUMP : TOML Memoisation Dump
# Stamp: 2025-12-22 v1.0.0
# This file is itself a Cognitive Memoisation (CM) artefact.
# It defines TMLDUMP by example and by explicit semantic declaration.

[cm]
type = "Cognitive Memoisation"
dump_format = "TMLDUMP"
version = "1.0"
status = "normative"
authority = "human-curated"
rehydratable = true

# Predicate: This artefact encodes cognition, not presentation.
encodes_cognition = true
encodes_presentation = false

# Predicate: This artefact is intended for round-trip knowledge engineering.
round_trip_capable = true


[identity]
title = "TMLDUMP Definition"
scope = "definition-and-example"
finality = "parked"
audience = [
  "CM practitioners",
  "future readers not present at creation",
  "LLMs rehydrating cognition"
]


[description]
summary = """
TMLDUMP (TOML Memoisation Dump) is a pure TOML output format for
Cognitive Memoisation (CM).

A TMLDUMP externalises human and LLM cognition so that it can be
recovered, resumed, and extended after session loss, time gaps,
or tool changes.

TMLDUMP captures the same cognitive elements as MWDUMP, but does so
using explicit structure rather than markup or layout.
"""

what_it_does = """
TMLDUMP records:
- episodic human input
- LLM analysis and inference
- explicit assertions
- derived conclusions
- unresolved cognition
- context and intent

It preserves these as a cognitive recording, not as a playback transcript.
"""

what_it_is_not = """
TMLDUMP is not:
- a publishing format
- a chat transcript
- a replay log
- a visual document

Rendering TMLDUMP into other formats is optional and derivative.
"""


[semantic_model]
explanation = """
Cognitive Memoisation distinguishes between:
- episodic cognition (what happened)
- declarative cognition (what is claimed)
- inferential cognition (what follows)

TMLDUMP makes these distinctions explicit using typed structures.
"""

# Predicate: Episodic input is first-class.
episodic_is_first_class = true

# Predicate: Inferences must be bindable to prior cognition.
inference_binding_required = true


[episodic_events]
explanation = """
Episodic events record cognitive acts as they occurred.
They are not transcripts for playback, but semantic recordings
that preserve intent, causality, and context.
"""

# Each episodic event is typed and attributable.
[[episodic_events.event]]
id = 1
actor = "human"
event_type = "intent"
content = """
I want to define a CM export format that captures everything MWDUMP can,
but without relying on markup or fragile layout.
"""

[[episodic_events.event]]
id = 2
actor = "llm"
event_type = "analysis"
content = """
Pure TOML is sufficient to encode all CM semantic requirements,
including episodic input, assertions, and inferences.
"""
derives_from = [1]

[[episodic_events.event]]
id = 3
actor = "human"
event_type = "directive"
content = """
Produce a definition that can be reused and rehydrated later
without explanation.
"""

[[episodic_events.event]]
id = 4
actor = "llm"
event_type = "inference"
content = """
A self-describing TMLDUMP can function as both definition and test artefact.
"""
derives_from = [2, 3]


[assertions]
explanation = """
Assertions are explicit claims made during cognition.
They are intended to be read as true within the scope of the artefact,
subject to future revision.
"""

[[assertions.claim]]
id = "A1"
text = "TMLDUMP can capture all cognitive elements permitted in MWDUMP."

[[assertions.claim]]
id = "A2"
text = "Explicit structure reduces cognitive entropy during round-trip rehydration."

[[assertions.claim]]
id = "A3"
text = "Cognition can be externalised without relying on markup or presentation."


[inferences]
explanation = """
Inferences are derived conclusions that follow from episodic events
and assertions. They represent bound reasoning, not free speculation.
"""

[[inferences.result]]
id = "I1"
text = "If cognition is made explicit, format becomes an implementation detail."
derived_from_assertions = ["A1", "A2"]

[[inferences.result]]
id = "I2"
text = "A pure TOML CM artefact is easier to preserve and rehydrate than markup-based formats."
derived_from_assertions = ["A2", "A3"]


[unresolved]
explanation = """
Unresolved cognition is preserved intentionally.
CM does not require premature closure.
"""

dangling_cognates = [
  "formal minimal TMLDUMP schema",
  "tooling for episodic event visualisation"
]


[rehydration]
explanation = """
This section provides guidance for resuming cognition
without rediscovery.
"""

resume_from = [
  "description.summary",
  "assertions",
  "inferences"
]

suggested_next_steps = [
  "use this TMLDUMP in a new CM session",
  "extend it with real episodic events",
  "validate round-trip fidelity"
]


[status]
parked = true
safe_to_copy = true
safe_to_reuse = true
safe_to_extend = true

# Predicate: This artefact is complete enough to stand alone.
self_contained = true

# Predicate: This artefact is suitable for long-term external memory.
long_term_external_memory = true

Transclusion D - CBS (redacted)

Redaction of Cognitive Behavioural Synopsis material of the human is valid under CM-1, because the CBS material is illustrative and does not contain normative sections, authority model, invariants, and procedural semantics. CBS content is not required for conformance or application of the framework.