Meta-Symbolic Rule Reflection

batch: First Iteration/Batch 36

slug: reflexivity

slug: representation

slug: ontology

slug: schema

slug: metacognition

slug: abstraction

slug: normativity

slug: versioning

slug: interoperability

components:
Symbol System Map
Rule Assumption
Meta-Level Critique
Edge-Case and Blind-Spot Inventory
Revision Proposal
Validation and Governance
Legacy Mapping Table
Stakeholder Language Sample
Downstream Consequence Trace
Revision Acceptance Criteria
Change Control Record
Dissent and Open Question Record

mechanisms:
Ontology Revision Session
Taxonomy Redesign Workshop
Language / Rule Critique
Category Boundary Audit
Paradigm Review
Governance Rule Review
Model-Class Revision
Edge-Case Walkthrough
Versioned Schema Change
Meta-Cognitive Reflection Prompt

essence_one_line: Examine and revise the symbol system, categories, or rules used for reasoning rather than only applying them.

compression_statement: When a system is trapped by its own categories or rules, step to a meta-symbolic level to inspect, critique, and revise the symbolic framework itself.

core_intuition: A symbolic system does not merely describe reality; it shapes what counts as a case, what distinctions are visible, what actions are allowed, and what evidence seems relevant. When the framework itself becomes distorting, better reasoning requires stepping above the system, inspecting its assumptions and consequences, and revising the rules by which reasoning proceeds.

canonical_formula: symbol/rule system + recurring mismatch or blind spot + meta-level critique + revision proposal + validation/governance => revised framework for reasoning and action

structural_problem: Actors apply an existing symbolic system, classification, or rule set even though it may be shaping the problem incorrectly.

condition: Actors repeatedly classify, evaluate, route, or reason through an inherited category system even though edge cases, exceptions, or harms show that the categories are no longer adequate.

condition: A rule set is being followed correctly but produces outcomes that seem arbitrary, brittle, outdated, illegible, unfair, or disconnected from the purpose the rule was meant to serve.

condition: People cannot express an important distinction because the available vocabulary, notation, schema, or model primitives do not contain it.

condition: Disagreements persist because participants debate inside a symbolic framework whose assumptions are never named.

condition: A taxonomy, ontology, rubric, model class, policy definition, workflow state, or governance category controls downstream decisions and has started to drift from reality.

condition: The framework has accumulated patches, exceptions, workarounds, and miscellaneous buckets that signal a deeper symbolic mismatch.

condition: Changing an individual decision would not solve the problem because the same symbolic or rule structure will keep recreating the distortion.

symptom: Cases are forced into categories that everyone recognizes as technically valid but practically misleading.

symptom: Users create unofficial labels, shadow workflows, spreadsheets, or exceptions to compensate for an inadequate official framework.

symptom: The same term is used by different groups with incompatible meanings, causing repeated coordination failures.

symptom: A rule or category appears neutral, but its downstream effects systematically privilege some cases while making others invisible.

symptom: The framework resists new evidence because anomalies are treated as one-off exceptions rather than signals that the rules need revision.

symptom: Debates circle around whether a case fits a category instead of asking whether the category should exist in its current form.

symptom: A representation, schema, or rule language cannot encode relationships that matter for reasoning, accountability, or action.

root_tension: Symbol systems are necessary for cognition, coordination, and governance because they compress reality into usable categories and rules. The same compression can become a trap when the categories, rules, or symbols become invisible infrastructure that limits thought, hides consequences, or forces reality to fit a stale framework.

case: The current symbolic framework is sound, but people need to choose a clearer diagram, medium, or notation for an already accepted structure; use representation_fit_selection.

case: The main problem is that a mental model is hidden inside someone’s head and needs to be made visible; use cognitive_representation_externalization unless the symbol/rule system itself needs revision.

case: The task is to clarify entities and relations in a domain model without a second-order critique of the framework’s assumptions; use ontology_clarification.

case: The issue is a one-time rewording or presentation frame that affects interpretation; use frame_shift_intervention or a framing audit rather than revising a durable symbolic system.

case: The intervention is personal reflection about one’s thinking process without examining categories, symbols, rules, or representational primitives; use metacognitive monitoring or reflexive self-monitoring.

case: The rule set is intentionally fixed for legal, safety, reproducibility, or interoperability reasons and cannot be changed in the current scope; the appropriate action may be escalation, exception handling, or documentation rather than revision.

structural_intervention: Identify the symbol/rule system, inspect assumptions and blind spots, propose revisions, test the revised system, and govern changes.

Name the symbolic system or rule set

logic: Identify the durable categories, terms, notations, schemas, taxonomies, rubrics, eligibility definitions, workflow states, or decision rules that are shaping reasoning.

Map how the framework is used

logic: Trace where the symbols or rules enter decisions, documentation, measurement, communication, routing, accountability, incentives, or evidence interpretation.

Surface embedded assumptions

logic: Make explicit what the framework treats as equivalent, separable, normal, deviant, measurable, irrelevant, impossible, or outside the domain.

Collect mismatches and edge cases

logic: Use anomalies, excluded cases, shadow workarounds, ambiguous examples, stakeholder interpretations, and failure records to reveal blind spots.

Critique at the meta level

logic: Ask whether the framework itself is still fit for purpose, not merely whether individual actors are applying it correctly.

name: Propose a revised symbolic/rule structure

logic: Revise categories, definitions, relations, inheritance rules, labels, model primitives, escalation rules, or governance boundaries in a concrete form.

name: Test old and revised systems against cases

logic: Compare how each framework handles normal cases, edge cases, contested cases, and downstream consequences.

Govern adoption and future revision

logic: Document version changes, migration rules, affected artifacts, responsibilities, review cadence, and open questions.

rule: Use this archetype when recurring failure appears to originate in the categories, symbols, or rules used for reasoning, not only in bad execution.

rule: Do not revise a symbolic system only because it is imperfect; revise when the mismatch affects comprehension, coordination, legitimacy, action, or evidence interpretation.

rule: Require concrete cases before changing high-stakes categories; abstract critique alone is not enough.

rule: Preserve interoperability and continuity unless the old framework’s distortion is more costly than the migration burden.

rule: Represent what the revision changes and what it intentionally does not change.

rule: Include affected users or downstream actors when category or rule changes alter responsibilities, access, eligibility, evaluation, or visibility.

rule: Use review and versioning when the revised framework will be embedded in systems, policies, reports, standards, or recurring practice.

invariant: The intervention must critique the symbolic/rule system itself rather than merely apply existing rules more carefully.

invariant: The revised framework must remain usable for its intended task; critique that destroys all operational distinctions without replacing them is not sufficient.

invariant: Edge cases and consequences must be documented so the revision is grounded in use rather than purely conceptual preference.

invariant: Meaning changes must be traceable: users should know what changed, why, and how to translate from old to new categories or rules.

invariant: The revision must not hide uncertainty, dissent, or contested value judgments behind apparently neutral categories.

invariant: Governance must define who can revise the symbolic system and how future drift will be detected.

outcome: Actors notice and revise assumptions embedded in categories, labels, model classes, or rules.

outcome: Classification, reasoning, routing, and communication better match the domain and intended purpose.

outcome: Edge cases, excluded cases, and ambiguous cases become visible instead of being forced into misleading categories.

outcome: Teams can distinguish errors caused by bad application from errors caused by the framework itself.

outcome: Revised rules or symbols are documented, validated, and governed rather than left as informal language drift.

outcome: The system becomes more adaptable because its symbolic infrastructure can be intentionally reviewed and updated.

prose_essence:
Meta-Symbolic Rule Reflection is the intervention pattern for moments when the inherited categories, rules, labels, or representational primitives are no longer neutral tools. They have become part of the problem. The intervention asks people to stop applying the symbolic system as given and instead inspect how that system makes some distinctions obvious, some cases invisible, and some actions legitimate.

The archetype is not simply “thinking about thinking.” It is reflection on the symbolic infrastructure of thought: the taxonomy, ontology, rubric, policy category, workflow state, model class, decision rule, term set, or classification language through which reasoning happens.

prose_when_to_use:
Use this archetype when a recurring problem appears to be generated by the framework used to classify and reason about cases. Typical triggers include repeated edge cases, shadow categories, miscellaneous buckets, workarounds, ambiguous labels, rules that produce compliant but absurd outcomes, or arguments that never question the vocabulary they depend on.

It is especially useful when changing one decision will not help because the same categories and rules will keep recreating the distortion.

prose_structural_problem:
The structural problem is that actors keep applying an inherited symbolic system even though the system is shaping the problem incorrectly. A framework that once compressed reality into usable distinctions now hides important variation, legitimizes unhelpful actions, or prevents people from expressing what they need to express.

The tension is unavoidable: shared symbols and rules make coordination possible, but they also make some things easier to see than others. This archetype preserves the usefulness of symbolic compression while making that compression reviewable and revisable.

prose_intervention_logic:
The intervention starts by naming the symbolic system or rule set under review. It then maps how the system is used, surfaces embedded assumptions, collects edge cases and blind spots, and critiques the framework from one level above routine application. The result should be a concrete revision proposal, not only a philosophical critique.

A successful intervention tests the old and revised systems against normal cases, edge cases, contested cases, and downstream consequences. It also governs adoption through versioning, migration notes, responsibility assignments, and review cadence.

prose_key_components:
- **Symbol System Map (`symbol_system_map`)** — Identifies the categories, terms, rules, notations, labels, distinctions, and inference conventions that currently organize reasoning. This component prevents the intervention from becoming vague reflection. It names the actual symbolic or rule system being inspected: a taxonomy, rubric, ontology, modeling language, governance rule set, diagnostic code, pricing category, policy definition, or reasoning convention.
- **Rule Assumption (`rule_assumption`)** — Surfaces the assumptions embedded in the symbolic system, including what the rules treat as equivalent, impossible, normal, deviant, important, or ignorable. The goal is not merely to list rules but to reveal their implicit commitments. A category may assume stable identity, a metric may assume commensurability, a routing rule may assume clean boundaries, or a notation may privilege certain relations over others.
- **Meta-Level Critique (`meta_level_critique`)** — Moves one level above routine application to evaluate whether the symbolic framework itself is distorting interpretation, coordination, legitimacy, or action. This is the defining component. Instead of asking whether a case was classified correctly under the current rules, the critique asks whether those rules and categories should be trusted, revised, split, merged, retired, or governed differently.
- **Edge-Case and Blind-Spot Inventory (`edge_case_and_blind_spot_inventory`)** — Collects cases, harms, anomalies, exclusions, mismatches, and recurring workarounds that reveal limits of the current symbolic or rule system. Concrete edge cases keep the critique grounded. They show where the current categories erase variation, force false choices, hide causal relations, route people incorrectly, or make important distinctions impossible to express.
- **Revision Proposal (`revision_proposal`)** — Specifies how the symbol system, categories, rule definitions, inheritance logic, or classification boundaries should change. A proposal may split a category, merge overlapping labels, add a relation type, change a rule condition, introduce a new state, rename a harmful label, retire a misleading distinction, or add governance for when the system may be changed.
- **Validation and Governance (`validation_and_governance`)** — Tests the revised framework against cases and assigns responsibility for versioning, adoption, exception handling, and future review. Without governance, meta-symbolic reflection can produce clever new vocabulary that never changes practice. Validation and governance connect the revised symbolic framework to use, accountability, migration, and ongoing correction.

prose_common_mechanisms:
The following mechanisms implement the archetype in different settings. They are not the archetype itself; each becomes Meta-Symbolic Rule Reflection only when it maps a symbolic/rule system, critiques its assumptions, proposes revision, tests consequences, and governs the revised framework.

- **Ontology Revision Session (`ontology_revision_session`)** — This facilitated review method implements the archetype by: Reviews and revises entities, relations, categories, and boundary rules when the current ontology constrains reasoning incorrectly. A mechanism under the archetype, not the archetype itself. It is useful when the symbolic framework is explicitly ontological, such as a domain model, product taxonomy, research classification, or encyclopedia ontology.
- **Taxonomy Redesign Workshop (`taxonomy_redesign_workshop`)** — This classification revision method implements the archetype by: Reworks categories, parent-child relations, labels, and inclusion rules so a classification system better fits use cases and edge cases. This mechanism implements the archetype when the main symbolic problem is categorical. It should not be treated as a standalone archetype unless the taxonomy redesign pattern itself generalizes beyond meta-level critique.
- **Language / Rule Critique (`language_rule_critique`)** — This discursive analysis method implements the archetype by: Examines how terms, labels, definitions, grammar, or decision rules make certain interpretations easier and others difficult or invisible. Useful when the framework is not formal code or taxonomy but a durable language practice, policy vocabulary, rubric, operating rule, or professional convention.
- **Category Boundary Audit (`category_boundary_audit`)** — This boundary review method implements the archetype by: Tests category boundaries against ambiguous, excluded, borderline, and anomalous cases. This can be a mechanism within this archetype, although reconciliation also keeps category_boundary_audit as a possible neighboring archetype when the boundary audit itself is the main intervention.
- **Paradigm Review (`paradigm_review`)** — This high level framework review implements the archetype by: Inspects whether the governing worldview, explanatory model, or disciplinary paradigm still supports reliable reasoning and action. Use carefully. Not every disagreement is a paradigm problem, and the mechanism should produce testable revision proposals rather than broad rhetoric about paradigm shifts.
- **Governance Rule Review (`governance_rule_review`)** — This institutional rule review implements the archetype by: Evaluates whether decision rules, escalation paths, eligibility definitions, or authority categories are producing distorted or illegitimate outcomes. Implements the archetype in policy, organizational, and administrative settings where rules are both symbolic and operational.
- **Model-Class Revision (`model_class_revision`)** — This modeling framework revision implements the archetype by: Reconsiders the class of models or representational primitives allowed for reasoning when the current class cannot express relevant structure. Examples include moving from linear to network models, from static states to transitions, from single-label classes to multi-label or relational representations, or from fixed categories to versioned schemas.
- **Edge-Case Walkthrough (`edge_case_walkthrough`)** — This stress test method implements the archetype by: Runs difficult cases through the current and revised frameworks to expose hidden assumptions, contradictions, and practical consequences. This mechanism grounds reflection in cases. It is especially useful before changing a symbolic system that routes people, resources, alerts, claims, or responsibilities.
- **Versioned Schema Change (`versioned_schema_change`)** — This change control method implements the archetype by: Implements revisions through explicit versioning, migration notes, backwards-compatibility decisions, and review cadence. Useful where symbolic systems are embedded in databases, APIs, standards, operational taxonomies, formal ontologies, or recurring documentation.
- **Meta-Cognitive Reflection Prompt (`meta_cognitive_reflection_prompt`)** — This reflection prompt implements the archetype by: Prompts users to ask what categories, rules, symbols, or assumptions are shaping their reasoning before applying the framework again. A prompt may trigger the archetype but does not constitute it. It must lead to mapped assumptions, critique, revision, and governance to count as meta-symbolic rule reflection.

prose_failure_modes:
- **Cosmetic renaming** — Cause: The team changes labels but leaves decision rules, incentives, databases, metrics, and authority structures untouched. Mitigation: Trace downstream consequences and require implementation artifacts that show how the revised symbolic system changes use.
- **Infinite meta-debate** — Cause: Participants keep questioning categories without evidence, acceptance criteria, or decision authority. Mitigation: Ground critique in cases, define revision acceptance criteria, and timebox review cycles.
- **Overcomplicated framework** — Cause: Every edge case is converted into a new category, rule, or relation. Mitigation: Balance expressiveness with usability; use miscellaneous categories deliberately and govern when they trigger revision.
- **Power-preserving revision** — Cause: Incumbent actors revise vocabulary in ways that appear reflective while preserving hidden exclusions or authority. Mitigation: Include affected users, dissent records, and consequence traces; audit who benefits from the revised categories.
- **Lost continuity** — Cause: The old and new frameworks are not mapped, making historical comparison, reporting, or migration difficult. Mitigation: Create a legacy mapping table, version record, and transition notes before adoption.
- **Premature abandonment of useful categories** — Cause: Critique treats all compression as distortion and discards operational distinctions that remain necessary. Mitigation: Preserve target invariants and test revised frameworks against normal as well as edge cases.
- **Unowned revision** — Cause: A revised symbolic framework is proposed but no one is responsible for documentation, training, adoption, and future review. Mitigation: Assign validation and governance responsibilities before treating the revision as complete.

prose_neighbor_distinctions:
- **Representation Fit Selection (`representation_fit_selection`)** — Representation Fit Selection chooses a representation form for a task; Meta-Symbolic Rule Reflection critiques and revises the symbolic categories, rules, or primitives that define the task and what can be represented.
- **Cognitive Representation Externalization (`cognitive_representation_externalization`)** — Externalization moves an implicit model into a shareable artifact; Meta-Symbolic Rule Reflection asks whether the symbols and rules of the model itself need revision.
- **Ontology Clarification (`ontology_clarification`)** — Ontology Clarification clarifies entities, categories, and relations in a domain; this archetype more explicitly performs second-order critique and governance of the symbolic/rule system.
- **Schema Update Protocol (`schema_update_protocol`)** — Schema Update Protocol revises an existing schema after mismatch or drift; Meta-Symbolic Rule Reflection covers broader symbolic, categorical, rule, language, and model-class critique.
- **Frame Shift Intervention (`frame_shift_intervention`)** — Frame shifting changes interpretive lens to open action; this archetype changes the durable symbol/rule system that generates lenses, classifications, and allowed moves.
- **Reflexive Self-Monitoring (`reflexive_self_monitoring`)** — Reflexive self-monitoring observes the reasoning process; Meta-Symbolic Rule Reflection inspects the symbolic infrastructure that the reasoning process uses.
- **Category Boundary Audit (`category_boundary_audit`)** — Category Boundary Audit is narrower and focuses on inclusion/exclusion boundaries; this archetype can include category boundaries but also includes rules, language, model classes, and governance.
- **Ontology Design (`ontology_design`)** — Ontology design may create a domain model from scratch; this archetype is specifically triggered by reflective critique and revision of a framework that is already shaping reasoning or action.
- **Structured Sensemaking (`structured_sensemaking`)** — Structured Sensemaking organizes ambiguous evidence to form understanding; this archetype revises the symbolic categories and rules through which understanding is formed.

prose_cross_domain_examples:
- **encyclopedia_ontology**: A drafting team pauses before merging two candidate archetypes and reviews whether its alias rules are collapsing distinct intervention patterns. The intervention critiques the rules and categories used to reason about the encyclopedia itself.
- **software_workflow**: An engineering organization revises issue states because “blocked,” “waiting,” and “closed” no longer express responsibility or next action. The symbolic workflow categories shape action, reporting, and accountability.
- **service_design**: A service team revises customer categories after discovering that the inherited segmentation hides users who move between contexts. The categories are not just labels; they drive design priorities and resource allocation.
- **education**: An instructor revises a rubric after realizing that its categories measure presentation polish more than conceptual understanding. The rubric is a rule system that shapes evidence, judgment, and learner behavior.
- **policy_review**: A program reviews eligibility definitions after repeated edge cases show that the rule language excludes intended beneficiaries. The problem is embedded in definitions and boundaries, not merely in staff application.
- **research_modeling**: A research group splits a construct into two variables after anomalies reveal that the old category merged distinct mechanisms. The accepted symbolic construct constrained what evidence could mean.

Extended example: A knowledge platform uses a taxonomy to classify all support questions. Over time, many questions land in “general issue,” and teams disagree about whether those cases are bugs, documentation gaps, onboarding failures, or configuration problems. Instead of asking reviewers to classify more carefully, the platform team maps the taxonomy, traces how labels affect routing and metrics, surfaces the assumption that each ticket has one primary cause, and reviews edge cases. They revise the taxonomy to include relation tags, user-stage context, and multi-cause classifications; then they test old and revised schemes on historical tickets and document migration rules. The improvement comes from revising the symbolic framework, not from better diligence inside the old taxonomy.

prose_non_examples:
- **A team draws a concept map to explain an agreed domain model.** — The concept map externalizes cognition, but does not necessarily critique or revise the symbolic rule system.
- **A dashboard designer changes from a pie chart to a bar chart.** — This is representation-fit selection unless the underlying categories or measurement rules change.
- **A facilitator asks “What assumptions are we making?” and then continues with the same categories and rules.** — Assumption surfacing alone is not enough; the archetype requires symbol/rule revision and governance.
- **A policy changes a numeric threshold while preserving the same eligibility structure.** — That is parameter tuning inside an unchanged symbolic framework.
- **A brand team renames a user segment for more appealing messaging.** — Cosmetic relabeling does not count unless it changes reasoning rules, categories, consequences, or governance.

prose_tradeoffs:
- **Reflective depth versus operational stability** — Deep critique can improve the framework, but too much ongoing revision can make categories unstable and hard to use.
- **Expressiveness versus simplicity** — A richer symbolic system can handle more cases but may be harder for users to learn, apply, and govern.
- **Local fit versus interoperability** — A revised local framework may better fit context while reducing comparability with external standards, historical data, or partner systems.
- **Critical revision versus legitimacy** — Challenging inherited categories can surface hidden harms, but may also threaten identities, expertise, authority, or institutional commitments.
- **Precision versus flexibility** — More precise definitions can reduce ambiguity but may create brittle boundaries when domains evolve.
- **Governance burden versus drift risk** — Versioning and review require effort, but informal symbolic drift can produce invisible inconsistency and misclassification.

prose_invariants_to_preserve:
The intervention must preserve a genuine meta-level critique of the symbol/rule system itself. It must not collapse into better application of the old rules, cosmetic renaming, generic reflection, or a one-off framing tactic.

It should also preserve usability. A revised framework that names every nuance but cannot be used consistently has failed. The goal is not unlimited complexity; it is a better governed symbolic framework for reasoning and action.

prose_target_outcomes:
Target outcomes include clearer category boundaries, more expressive rules, fewer misleading forced classifications, better handling of edge cases, improved legitimacy of decisions, and a framework that can be intentionally revised rather than informally patched.

The deeper outcome is epistemic adaptability: actors can inspect and update the symbolic infrastructure that shapes their reasoning instead of being trapped inside it.

prose_parameter_dimensions:
Important tuning dimensions include the scope of revision, the level of abstraction, the stability of the old framework, the number of affected downstream systems, the degree of stakeholder participation, and the governance burden of change.

A narrow intervention may revise one rubric category or workflow state. A broad intervention may revise an ontology, model class, policy vocabulary, or governance rule set. High-stakes domains require stronger validation, traceability, authority, and migration planning.

prose_variants_and_near_names:
Recognized variants:

- **Classification Framework Reflection (`classification_framework_reflection`)** — Inspect and revise the classification scheme that sorts cases, people, objects, risks, or events into categories before the scheme keeps producing misleading conclusions or treatments.
- **Rule-System Revision Reflection (`rule_system_revision_reflection`)** — Inspect and revise the decision rules, escalation conditions, eligibility definitions, or inference conventions that structure action.
- **Symbolic Vocabulary Reflection (`symbolic_vocabulary_reflection`)** — Examine and revise the terms, labels, metaphors, and symbolic distinctions that make some interpretations natural while making others difficult to express.
- **Model-Class Reflection (`model_class_reflection`)** — Reconsider the class of models, primitives, or representational rules allowed for a problem when the current model class cannot express what matters.

Aliases and near names:

- **Meta-Symbolic Reflection (`meta_symbolic_reflection`)** — prime_name_or_near_name: Canonical prime motivating the archetype; not a separate draft under this batch.
- **Symbolic Rule Reflection (`symbolic_rule_reflection`)** — near_alias: Shorter near name for the same intervention when rules rather than symbols are emphasized.
- **Symbolic Framework Revision (`symbolic_framework_revision`)** — near_alias: Useful when the output is a revised symbolic framework; keep parent name if the reflective process is central.
- **Rule-System Revision (`rule_system_revision`)** — variant_or_mechanism: Use as a variant when the rule system is the central target; otherwise treat as a mechanism or component.
- **Ontology Revision (`ontology_revision`)** — mechanism_or_example: Roadmap classifies this as a defer/component candidate and reconciliation marks it do_not_draft_component_or_mechanism for Batch 036.
- **Taxonomy Redesign (`taxonomy_redesign`)** — mechanism_or_artifact: A common mechanism under the archetype, not the whole archetype unless taxonomy governance becomes a separate parent.
- **Language / Rule Critique (`language_rule_critique`)** — mechanism_family: A method for surfacing symbolic assumptions; not sufficient unless it leads to revision and governance.
- **Paradigm Review (`paradigm_review`)** — high_level_variant_or_mechanism: Can be a mechanism when the symbolic framework is a broad disciplinary or organizational paradigm.
- **Meta-Cognitive Reflection (`meta_cognitive_reflection`)** — near_name_but_boundary_needed: Do not collapse all metacognition into this archetype; this archetype targets symbolic/rule systems rather than general self-monitoring.

Collapsed mechanism-like candidates include `ontology_revision`, `ontology_revision_session`, `reflection_journal`, `taxonomy`, and `taxonomy_design`. These may support the archetype, but they should not be drafted as standalone archetypes for this batch.

Classification Framework Reflection

distinctive_feature: The key object of reflection is the categorical structure itself: category boundaries, hierarchy, equivalence rules, excluded cases, and consequences of belonging to a class.

distinct_from_parent: The parent covers any symbolic or rule framework. This variant narrows attention to classifications and taxonomies.

still_same_parent_because: The intervention still moves to a meta-level to revise the symbolic rules used for reasoning and action.

use_when: A taxonomy, rubric, label set, eligibility category, diagnostic class, or severity band repeatedly forces ambiguous cases into misleading boxes.

use_when: The classification scheme controls downstream routing, reporting, responsibility, incentives, or resource allocation.

use_when: The problem is not only a bad single classification but the category system that makes bad classifications likely.

Symbol System Map

role: Maps categories, boundaries, and hierarchy.

Edge-Case and Blind-Spot Inventory

role: Tests the scheme against cases it handles poorly.

Revision Proposal

role: Changes classes, labels, boundaries, or routing rules.

Taxonomy Redesign Workshop

role: Revises category structures.

Category Boundary Audit

role: Tests inclusion and exclusion logic.

Edge-Case Walkthrough

role: Stress-tests the revised categories.

example: A support team revises its incident categories after repeated “miscellaneous” tickets reveal hidden classes of failure.

domain: education

example: A department revises a rubric after discovering that its categories reward polish while hiding conceptual understanding.

failure_modes: Revised labels can create new exclusions or stigma if downstream consequences are not traced.

failure_modes: Classification debates can become endless if no acceptance criteria or governance process is defined.

Rule-System Revision Reflection

distinctive_feature: The intervention critiques the rule set that authorizes or constrains action, not only the language or categories used to describe cases.

distinct_from_parent: The parent includes symbol systems, categories, and models; this variant centers action-governing rules.

still_same_parent_because: It still uses meta-level critique, revision proposal, and governance to change a reasoning framework.

use_when: People are applying rules correctly but the rules themselves appear to generate distorted, unfair, brittle, or outdated outcomes.

use_when: A governance, operational, or reasoning process depends on implicit rule assumptions that are rarely examined.

use_when: Rule revisions require validation and change control because they affect recurring decisions.

Rule Assumption

role: Surfaces hidden rule premises.

Downstream Consequence Trace

role: Shows what the rules do in practice.

Validation and Governance

role: Controls adoption and review of revised rules.

Governance Rule Review

role: Examines institutional rules.

Edge-Case Walkthrough

role: Tests rules against cases.

Versioned Schema Change

role: Documents rule revisions.

example: A team revises escalation rules after noticing that the current threshold hides slow-building failures.

domain: policy

example: An eligibility process revises definitions after edge cases show that compliant application creates arbitrary exclusion.

failure_modes: Rule review can become a legitimacy exercise if users affected by the rules are not represented.

failure_modes: Changing rules without migration guidance can break comparability across time.

Symbolic Vocabulary Reflection

distinctive_feature: The target is the expressive vocabulary that structures reasoning, not just a presentation frame or communication tactic.

distinct_from_parent: The parent includes all symbolic and rule frameworks; this variant centers language and label systems.

still_same_parent_because: The intervention still critiques and revises the symbolic machinery used to reason.

use_when: A durable vocabulary or label set causes misunderstanding, stigma, false equivalence, missing distinctions, or category drift.

use_when: People debate within inherited language even though the language itself is shaping the disagreement.

use_when: Changing the vocabulary must also change rules, documentation, or practice rather than merely improve messaging.

Stakeholder Language Sample

role: Reveals actual language use and interpretation.

Rule Assumption

role: Shows what the vocabulary presupposes.

Revision Proposal

role: Defines revised terms and usage rules.

Language / Rule Critique

role: Analyzes terms and labels.

Glossary Redesign

role: Documents revised vocabulary.

Stakeholder Interpretation Review

role: Checks how revised terms are understood.

example: A team revises internal labels after noticing that “power user” hides accessibility and onboarding differences.

domain: research

example: A study group revises terms that conflate measurement categories with causal explanations.

failure_modes: Vocabulary revision can become cosmetic if decision rules and artifacts continue using old distinctions.

failure_modes: New terms can reduce clarity if they are introduced without examples and migration guidance.

Model-Class Reflection

distinctive_feature: The decisive move is changing what kinds of representations or model primitives are legitimate for reasoning.

distinct_from_parent: The parent covers symbol and rule systems broadly; this variant centers model classes and representational primitives.

still_same_parent_because: It still critiques and revises the symbolic framework at a meta level rather than simply applying it.

use_when: Reasoning repeatedly fails because the accepted model type excludes dynamics, relations, uncertainty, scale, feedback, or multiple memberships.

use_when: Actors are not merely choosing among diagrams but questioning the representational primitives themselves.

use_when: The revised framework must be validated against use cases before replacing the old model class.

Symbol System Map

role: Shows current model primitives and allowed relations.

Edge-Case and Blind-Spot Inventory

role: Shows what the model class cannot express.

Revision Acceptance Criteria

role: Tests whether the new model class improves reasoning.

Model-Class Revision

role: Changes the modeling framework.

Paradigm Review

role: Inspects high-level assumptions.

Comparative Model Walkthrough

role: Runs cases through old and revised model classes.

domain: analytics

example: A team moves from single-label customer categories to relational segments after realizing customers occupy multiple contexts.

example: Architects revise a static component model into a state-transition model after failures arise from lifecycle changes.

failure_modes: Model-class changes can become overengineered if the existing model class is adequate for the task.

failure_modes: Sophisticated primitives can make the framework less usable if users cannot interpret them consistently.

near_names:
Meta-Symbolic Reflection
Symbolic Rule Reflection
Symbolic Framework Revision
Rule-System Revision
Ontology Revision
Taxonomy Redesign
Language / Rule Critique
Paradigm Review
Meta-Cognitive Reflection


Metacognitive Monitoring Loop

type: archetype

source: generated

batch: First Iteration/Batch 37

Metacognitive Check

notes: Use when it means checking and adjusting the reasoning process, not generic reflection.

Thinking About Thinking

notes: Informal phrase; too broad to use as canonical archetype name.

Reasoning Self-Monitoring

notes: Best for individual variants of the parent loop.

related_primes: feedback uncertainty heuristics bounded_rationality

slug: feedback

slug: uncertainty

slug: heuristics

components:
Reasoning Goal
Process Monitor
Monitoring Signal Set
Confidence Check
Reasoning Failure Mode Label
Strategy Adjustment
Reflection Step
Cognitive Load Signal
Monitoring Cadence
Progress Marker
External Feedback Source
Learning Memory
Escalation Trigger

mechanisms:
Think-Aloud Protocol
Reflection Prompt
Strategy Checklist
Learning Journal
Metacognitive Coaching
Decision-Process Review
Reasoning Retrospective
Confidence Rating Rubric

essence_one_line: Monitor and regulate the thinking process itself while solving a problem.

compression_statement: When reasoning can drift, overload, bias, or stall, add a loop that watches process signals such as confidence, load, progress, and evidence use, then changes the reasoning strategy before errors harden into conclusions.

core_intuition: People often keep pushing on the content of a problem even when their method of thinking has stopped working. A metacognitive loop creates a second-order vantage point: it asks how the reasoning is going, not only what answer is emerging, and gives the thinker permission to change strategy.

canonical_formula: reasoning goal + process signals + failure-mode label + strategy adjustment + reflection = regulated thinking loop

structural_problem: The thinker or group focuses only on object-level content while the reasoning process itself may be overloaded, miscalibrated, biased, stuck, or using the wrong strategy.

trigger_conditions: A problem is complex enough that the first reasoning strategy may not fit the task.

trigger_conditions: Confidence, confusion, cognitive load, or repeated failed attempts are changing during the work.

trigger_conditions: The cost of a reasoning error is high enough that process drift should be caught before commitment.

trigger_conditions: A learner or team must improve not only the current answer but also future strategy selection.

trigger_conditions: The work involves uncertainty, ambiguous evidence, competing hypotheses, or unfamiliar problem structure.

symptoms: People keep working harder with the same strategy even though progress has stalled.

symptoms: Confidence rises faster than evidence quality, or confidence collapses without a clear reason.

symptoms: The group debates conclusions while ignoring whether its reasoning process is narrowing prematurely.

symptoms: A learner repeats a familiar study or problem-solving tactic even when it no longer works.

symptoms: Reasoning becomes circular, overloaded, fragmented, or fixated on a first interpretation.

symptoms: After success or failure, no one can explain which reasoning strategy helped or hurt.

root_tension: Object-level reasoning consumes attention, but the quality of that reasoning depends on a process that also needs attention, feedback, and regulation. Monitoring too little allows hidden process failure; monitoring too much can overload or paralyze the thinker.

anti_signatures: The task is routine, low-uncertainty, and already governed by a reliable procedure that does not require strategy regulation.

anti_signatures: The main problem is a missing external signal about system state; use observability instrumentation rather than metacognitive monitoring.

anti_signatures: The main intervention is changing an incentive, cue, reward, or consequence; use reinforcement loop design or other behavior-design archetypes.

anti_signatures: The work is simply documenting what happened after the fact without changing future reasoning strategy.

anti_signatures: The main need is to revise the symbol system, categories, or rules of reasoning; use meta-symbolic rule reflection instead.

structural_intervention: Create a second-order loop around reasoning: name the reasoning goal, monitor process signals, diagnose the reasoning failure mode, choose a strategy adjustment, continue with the adjusted approach, and capture lessons for future reasoning.

State the reasoning goal

logic: Clarify what the thinking process is trying to accomplish and what kind of reasoning quality matters for the task.

Select process signals

logic: Choose lightweight indicators such as confidence, load, confusion, progress, evidence quality, fixation, or disagreement.

Monitor without derailing work

logic: Run the monitoring loop at a cadence that catches drift without consuming all attention.

Name the failure mode

logic: Translate signals into a process diagnosis such as overload, premature closure, shallow search, anchoring, circular reasoning, or strategy mismatch.

Adjust the reasoning strategy

logic: Make a concrete change: decompose, externalize, seek counterevidence, change representation, slow down, consult a peer, test assumptions, or switch methods.

Continue and recheck

logic: Use the adjusted strategy and observe whether process signals improve or require another adjustment.

Reflect and store learning

logic: Capture what the episode revealed about strategy fit, recurring failure modes, and future checkpoints.

rule: If process signals show rising effort without progress, change strategy rather than merely adding more effort.

rule: If confidence is high but evidence quality is weak, lower commitment, seek disconfirming evidence, or mark uncertainty explicitly.

rule: If confusion rises, distinguish productive confusion from overload and choose either exploration, decomposition, or support.

rule: If the same explanation, frame, or tactic is repeated without new evidence, test for fixation or premature closure.

rule: If monitoring itself consumes too much attention, reduce cadence, simplify signals, or move monitoring to a facilitator or artifact.

rule: If a failure mode recurs across cases, update the default reasoning workflow rather than treating each occurrence as isolated.

invariant: The monitored object is the reasoning process itself.

why_it_matters: Without this invariant, the archetype collapses into generic progress tracking, observability, or performance review.

invariant: Monitoring leads to a possible strategy adjustment.

why_it_matters: Reflection without a change path becomes a ritual rather than a regulatory loop.

invariant: Confidence remains tied to evidence and uncertainty.

why_it_matters: Metacognitive monitoring can otherwise amplify feelings of certainty or anxiety instead of calibrating reasoning.

invariant: Process critique remains psychologically safe and non-punitive.

why_it_matters: People will hide uncertainty or confusion if monitoring is used as blame or surveillance.

invariant: Monitoring overhead stays proportional to task stakes and complexity.

why_it_matters: Over-monitoring can produce paralysis, rumination, or cognitive overload.

outcome: Earlier detection of reasoning drift, overload, fixation, and premature closure.

outcome: Better strategy selection during complex problem solving.

outcome: More calibrated confidence and clearer uncertainty labels.

outcome: Improved learning from reasoning episodes rather than only from outcomes.

outcome: Greater ability to explain and improve the process that produced a decision or solution.

prose_essence:
Metacognitive Monitoring Loop is the intervention pattern of stepping up one level from the object-level problem and asking how the thinking process is going. The point is not simply to reflect, journal, or talk about thinking. The point is to notice process signals, interpret them, and change the reasoning strategy before the current strategy quietly produces avoidable error.

A useful shorthand is: **watch the reasoning, name the process problem, change the strategy, and learn from the episode**.

prose_when_to_use:
Use this archetype when reasoning quality depends on strategy choice, confidence calibration, cognitive load, or the ability to notice when a line of thought is getting stuck. It is especially useful in complex problem solving, learning, diagnosis, incident response, research, strategic decision-making, design, and debugging.

It is less useful for routine execution tasks where the procedure is already reliable and the main risk is not reasoning drift. It is also not the right primary archetype when the real problem is missing external system visibility, incentives, or rule enforcement.

prose_structural_problem:
The structural problem is that object-level reasoning can monopolize attention. A person or group may keep debating the answer, running the same test, rereading the same material, or defending the same option while the reasoning process itself is failing. The failure can look like overconfidence, underconfidence, overload, fixation, circular reasoning, premature closure, shallow search, or a strategy that no longer fits the task.

The hard part is proportionality. Too little monitoring lets errors harden into conclusions. Too much monitoring creates introspective load, interruption, or rumination.

prose_intervention_logic:
The intervention creates a regulatory loop around cognition. First, define the reasoning goal: what kind of thinking does this task require? Next, select process signals such as confidence, confusion, load, progress, evidence quality, or repeated failure. Then monitor those signals at a cadence that fits the stakes. When a signal indicates trouble, name the failure mode and choose a strategy adjustment.

The adjustment must be concrete. It might be decomposing the problem, drawing an external representation, seeking counterevidence, changing frames, asking a peer, slowing down, or escalating to a different method. Finally, the loop closes by reflecting on what the episode taught about future reasoning.

prose_key_components:
### Reasoning Goal

Reasoning Goal is the part of the archetype that defines the cognitive task, desired reasoning quality, and success criteria for the thinking process being monitored. Without a reasoning goal, the monitor has no basis for judging whether the current strategy is appropriate.
### Process Monitor

Process Monitor is the part of the archetype that observes the reasoning process itself rather than only the object-level answer, decision, or output. The monitor may be the thinker, a facilitator, a coach, a checklist, or a lightweight signal system; its object is process quality.
### Monitoring Signal Set

Monitoring Signal Set is the part of the archetype that specifies the cues that indicate whether reasoning is healthy, stuck, overloaded, biased, or drifting. Typical signals include confidence, confusion, cognitive load, progress, evidence quality, fixation, disagreement, and repeated failed attempts.
### Confidence Check

Confidence Check is the part of the archetype that compares expressed or felt certainty with evidence, uncertainty, task difficulty, and track record. Confidence monitoring prevents both overconfident closure and underconfident paralysis; it should be tied to evidence and not merely mood.
### Reasoning Failure Mode Label

Reasoning Failure Mode Label is the part of the archetype that names the detected process problem so the next move can target the right failure mode. Examples include anchoring, overload, circular reasoning, premature closure, untested assumption, shallow search, fixation, and strategy mismatch.
### Strategy Adjustment

Strategy Adjustment is the part of the archetype that changes the reasoning approach in response to monitoring signals and failure-mode diagnosis. Adjustments can include decomposing the problem, externalizing a representation, seeking counterevidence, slowing down, changing frame, asking for help, or switching methods.
### Reflection Step

Reflection Step is the part of the archetype that captures what was learned about the reasoning process so future reasoning can improve. Reflection closes the loop; without it, monitoring may fix the immediate case but not strengthen future strategy selection.

prose_common_mechanisms:
### Think-Aloud Protocol

Think-Aloud Protocol is a mechanism for implementing the archetype, not the archetype itself. It makes reasoning visible in real time so the thinker, coach, or team can notice assumptions, strategy, confusion, and confidence shifts. It should be selected only when it helps complete the loop from process signal to strategy adjustment and reflection.
### Reflection Prompt

Reflection Prompt is a mechanism for implementing the archetype, not the archetype itself. It provides short process-level questions that surface current strategy, evidence, uncertainty, alternatives, and next adjustment. It should be selected only when it helps complete the loop from process signal to strategy adjustment and reflection.
### Strategy Checklist

Strategy Checklist is a mechanism for implementing the archetype, not the archetype itself. It offers selectable reasoning moves and failure-mode checks so monitoring can lead to a concrete adjustment. It should be selected only when it helps complete the loop from process signal to strategy adjustment and reflection.
### Learning Journal

Learning Journal is a mechanism for implementing the archetype, not the archetype itself. It records reasoning choices, confidence, errors, strategy changes, and lessons so metacognitive learning accumulates over time. It should be selected only when it helps complete the loop from process signal to strategy adjustment and reflection.
### Metacognitive Coaching

Metacognitive Coaching is a mechanism for implementing the archetype, not the archetype itself. It uses a coach, facilitator, teacher, or peer to ask process-level questions and help choose reasoning adjustments. It should be selected only when it helps complete the loop from process signal to strategy adjustment and reflection.
### Decision-Process Review

Decision-Process Review is a mechanism for implementing the archetype, not the archetype itself. It reviews how a decision was reasoned through, including assumptions, evidence search, alternatives, confidence, and process quality. It should be selected only when it helps complete the loop from process signal to strategy adjustment and reflection.
### Reasoning Retrospective

Reasoning Retrospective is a mechanism for implementing the archetype, not the archetype itself. It after completion, reconstructs the reasoning process to identify what worked, what failed, and what future strategy should change. It should be selected only when it helps complete the loop from process signal to strategy adjustment and reflection.
### Confidence Rating Rubric

Confidence Rating Rubric is a mechanism for implementing the archetype, not the archetype itself. It translates confidence into explicit levels tied to evidence quality, uncertainty, and remaining checks. It should be selected only when it helps complete the loop from process signal to strategy adjustment and reflection.

prose_failure_modes:
Common failures include performative reflection, where prompts are completed without genuine strategy adjustment; over-monitoring paralysis, where the loop consumes more attention than the task; and uncalibrated confidence reporting, where confidence becomes a mood label rather than an evidence-linked judgment.

Other failures include self-critique spirals, monitor capture by a facilitator’s preferred reasoning style, noticing process problems without any permitted adjustment, and retrospective rationalization after the outcome is already known.

prose_neighbor_distinctions:
This archetype is distinct from **reflexive self-monitoring** because it focuses specifically on cognition and reasoning strategy rather than any form of self-observation. It is distinct from **observability instrumentation** because the hidden state being monitored is not an external system state but the reasoning process. It is distinct from **formative feedback loops** because the loop is not only about learning-progress evidence; it regulates thinking while a problem is being worked.

It is also distinct from **meta-symbolic rule reflection**, which examines the symbol systems, categories, or rules used for reasoning. Metacognitive monitoring may decide to invoke that deeper reflection, but it does not require revising the symbolic system. It is distinct from **heuristic guardrails** because guardrails are specific safeguards; the metacognitive loop decides when such safeguards or other strategies are needed.

prose_cross_domain_examples: In software debugging, a developer who has tried several failed fixes pauses to state the current hypothesis, evidence, confidence, and next test. In learning, a student notices that rereading feels fluent but recall remains weak, so they switch to retrieval practice and record the lesson. In incident response, a lead pauses a team that is anchoring on one familiar cause and asks for facts, assumptions, alternatives, and next evidence. In strategic planning, a group notices it is defending preferred options and changes the process to assumption testing.

prose_non_examples: A dashboard that reports system metrics is not this archetype unless those signals are used to monitor and adjust reasoning. A learning journal is not enough if it merely records feelings and never changes strategy. A debrief is not enough if it reviews outcomes but ignores the reasoning process. A checklist is not enough if it prescribes steps without monitoring whether the steps fit the current reasoning problem.

prose_tradeoffs: The main tradeoff is rigor versus speed. Monitoring can prevent costly errors, but it slows some tasks and interrupts flow. A second tradeoff is self-awareness versus cognitive load: asking people to observe their own thinking can help, but too much self-observation becomes the problem. A third tradeoff is visibility versus privacy, especially when think-aloud protocols or group process reviews expose uncertainty in front of others.

prose_invariants_to_preserve: The monitored object must remain the reasoning process itself. If the loop only tracks task status or external system state, it has drifted into generic monitoring or observability. Monitoring must also connect to an authorized adjustment path; otherwise it becomes empty reflection. Confidence must remain tied to evidence and uncertainty, not just feeling. Finally, the loop must preserve psychological safety and proportionality: people should be able to name confusion or uncertainty without punishment, and the monitoring burden should fit the stakes.

prose_target_outcomes: The archetype aims to catch reasoning drift earlier, improve strategy selection, calibrate confidence, reduce overload, and convert reasoning episodes into durable learning. A successful loop makes it easier to explain not only what conclusion was reached, but how the reasoning process was regulated along the way.

prose_parameter_dimensions:
The main tuning dimension is **cadence**: continuous self-monitoring, timed checkpoints, trigger-based pauses after failed attempts, pre-commitment checks, or post-task retrospectives. Another is **signal granularity**: a high-stakes diagnostic decision may need explicit confidence and evidence tags, while a writing session may only need a quick question about whether the current strategy is working.

A third dimension is **who monitors**. Solo work can use self-prompts or journals; team work may need a facilitator; learning contexts may use coaching; high-stakes decisions may need an independent process review. The design must also tune how much reasoning becomes visible, because making thought processes public can help learning but can also threaten privacy or psychological safety.

prose_variants_and_near_names:
Important variants include individual reasoning self-monitoring, collaborative reasoning process monitoring, real-time reasoning checkpoints, and reasoning retrospectives. These variants differ mainly by scale and timing: one person versus a group, in-process regulation versus post-task learning.

Near names include metacognitive check, thinking about thinking, reasoning self-monitoring, self-monitoring, reflection prompt, think-aloud protocol, learning journal, and strategy checklist. The near names should not be drafted separately unless they become full intervention patterns. Most are mechanisms that support the parent loop.

Individual Reasoning Self-Monitoring

short_definition: A single thinker uses explicit signals and checkpoints to monitor and regulate their own reasoning strategy.

distinctive_feature: The monitor and the reasoner are the same actor, so the design must reduce self-observation burden and avoid rumination.

distinct_from_parent: The parent can be individual or collective; this variant emphasizes self-administered monitoring during individual reasoning.

still_same_parent_because: It still uses the same loop: set a reasoning goal, monitor process signals, identify failure mode, adjust strategy, and reflect.

use_when: A learner, analyst, designer, clinician, engineer, or decision-maker is doing complex reasoning without a facilitator.

use_when: The main risk is unnoticed drift, overload, overconfidence, fixation, or strategy mismatch during solo work.

Reasoning Goal

role: Defines what the thinker is trying to accomplish.

Confidence Check

role: Compares felt certainty with evidence and task difficulty.

Strategy Adjustment

role: Changes the reasoning approach when monitoring signals indicate trouble.

Reflection Prompt

mechanism_type: template

role: Asks lightweight process questions during reasoning.

Learning Journal

mechanism_type: document

role: Captures reasoning choices and lessons over time.

example_domains: learning diagnosis software_debugging writing design

example: A developer pauses after failed fixes to ask whether they are testing assumptions, symptoms, or guesses.

domain: learning

example: A student notices rising confusion and switches from rereading to drawing a concept map and testing examples.

failure_modes: The self-check becomes vague reassurance rather than a real strategy change.

failure_modes: The thinker spends more effort watching themselves think than solving the problem.

name: Collaborative Reasoning Process Monitoring

short_definition: A group monitors the quality of its shared reasoning process while working through a problem or decision.

distinctive_feature: The monitored process is distributed across conversation, roles, artifacts, and social dynamics rather than inside one mind.

distinct_from_parent: The parent names the general loop; this variant emphasizes group-level reasoning signals, facilitation, and shared adjustment.

still_same_parent_because: The intervention still observes cognition-as-process and redirects strategy when the process is failing.

source_primes: metacognition reflexivity

use_when: A team must reason together under uncertainty, disagreement, time pressure, or high stakes.

use_when: The group may be converging too quickly, avoiding conflict, losing track of assumptions, or confusing participation with reasoning quality.

Process Monitor

role: Names who or what watches the group reasoning process.

Reasoning Failure Mode Label

role: Gives the group a shared name for the problem in its reasoning.

Strategy Adjustment

role: Specifies the group-level move that changes how the team reasons.

Decision-Process Review

mechanism_type: ritual

role: Reviews whether the team used an adequate reasoning process.

Metacognitive Coaching

role: Uses facilitative questions to regulate group reasoning.

example: A response lead notices the team is anchoring on one cause and pauses to separate facts, hypotheses, and next tests.

domain: strategy

example: A leadership group labels its current mode as option-defense and switches to assumption testing before choosing.

failure_modes: The monitor becomes a status judge rather than a helper for better reasoning.

failure_modes: Social pressure makes people report confidence or confusion inaccurately.

Real-Time Reasoning Checkpoint

short_definition: A lightweight pause inserted during active reasoning to detect drift, overload, or strategy mismatch before work continues.

distinctive_feature: The loop operates in-process rather than only after completion.

distinct_from_parent: The parent includes real-time and retrospective monitoring; this variant tunes the loop for immediate mid-course correction.

still_same_parent_because: It is still a metacognitive monitor-regulate-reflect loop, only compressed in time.

use_when: The reasoning process is unfolding in real time and errors will be expensive if noticed only after the outcome.

use_when: Participants need a brief interruption that changes how they think without derailing the task.

Monitoring Cadence

role: Sets when the checkpoint occurs.

Monitoring Signal Set

role: Specifies quick signals such as confidence, confusion, progress, and load.

Strategy Adjustment

role: Chooses a practical next move before continuing.

Strategy Checklist

mechanism_type: checklist

role: Offers quick decision points for changing reasoning tactics.

Think-Aloud Protocol

mechanism_type: method

role: Makes current reasoning visible enough to inspect.

domain: diagnosis

example: A team pauses before committing to ask what evidence would change the leading interpretation.

domain: debugging

example: A developer stops after repeated failed tests to state the current hypothesis and choose a different strategy.

failure_modes: The checkpoint interrupts flow too often.

failure_modes: The checkpoint asks questions but does not authorize an actual strategy change.

Reasoning Retrospective Loop

short_definition: A post-task reflection that reviews how the reasoning process worked and updates future reasoning strategy.

distinctive_feature: It turns reasoning experience into reusable process learning after the fact.

distinct_from_parent: The parent can regulate in real time; this variant emphasizes after-action learning and future strategy memory.

still_same_parent_because: It retains the monitor-diagnose-adjust-reflect logic, with adjustment carried into future work.

use_when: The immediate decision or task is complete, but the reasoning process should improve before the next similar case.

use_when: Teams or individuals need to distinguish outcome luck from reasoning quality.

Reflection Step

role: Captures what was learned about the reasoning process.

Learning Memory

role: Stores the process lesson for later reuse.

Reasoning Failure Mode Label

role: Names what went wrong or worked well.

Reasoning Retrospective

role: Facilitates post-task reasoning review.

Learning Journal

role: Stores individual or team reasoning lessons.

example: After an outage, reviewers ask which assumptions, evidence gaps, and coordination patterns shaped the diagnosis.

example: A learner reviews solved and missed problems to identify when to switch from recall to worked examples.

failure_modes: The retrospective judges people rather than the reasoning process.

failure_modes: The lesson is recorded but never reused as a future strategy adjustment.

near_names:
Metacognitive Check
Thinking About Thinking
Self-Monitoring
Reflection Prompt
Think-Aloud Protocol
Learning Journal
Strategy Checklist


name: Metanarrative Coherence and Internal Consistency Check

batch: Second Iteration/Pilot

aliases:
metanarrative consistency audit
narrative coherence validation
master narrative consistency check
grand narrative coherence review
internal story consistency audit
narrative contradiction scan
theory-of-change coherence validation

Grand Narrative (Metanarrative)

role: Names the comprehensive or totalizing narrative whose scope, claims, and authority make internal coherence consequential.

Validation

slug: validation

role: Names the check that the narrative’s claims, evidence, scope, and implications satisfy stated criteria rather than merely persuading.

name: Narrative Persuasion and Belief Formation

Framing

slug: framing

Sensemaking

slug: sensemaking

Causality

slug: causality

Teleology

slug: teleology

Historicism

slug: historicism

Completeness

slug: completeness

Constraint

slug: constraint

Relation

slug: relation

Triangulation

slug: triangulation

Paradox

slug: paradox

Perspective

slug: perspective

Complexity

slug: complexity

Invariance

slug: invariance

Revisionism

slug: revisionism

Authority

slug: authority

Legitimacy

slug: legitimacy

name: Coherence Breakdown Under External Interaction

components:
Metanarrative Scope Statement
Core Claim Inventory
Claim Dependency Map
Consistency Criteria
Evidence and Source-Link Register
Contradiction and Tension Log
Exception and Boundary Register
Reconciliation or Revision Plan
Terminology Glossary
Timeline and Periodization Map
Counter-Narrative Challenge Set
Stakeholder Interpretation Map
Versioned Narrative Record

mechanisms:
Claim-Lattice Mapping
Contradiction Scan
Causal-Temporal Trace
Scope-Boundary Stress Test
Term-Stability Review
Evidence-to-Claim Traceability
Counter-Narrative Probe
Exception Classification
Revision Diff Review
Red-Team Coherence Review

essence_one_line: Turn a sweeping story into an auditable claim structure, then test whether its claims, exceptions, evidence links, and implied conclusions can all hold together.

compression_statement: When a broad narrative organizes interpretation or action, this archetype decomposes it into scope, claims, dependencies, evidence links, exceptions, and implied commitments; it then detects contradictions, semantic shifts, unsupported exceptions, causal-temporal mismatches, and scope creep, producing a revision path that preserves legitimate complexity while removing incoherence.

core_intuition: A metanarrative can feel persuasive because it is fluent and comprehensive. Coherence validation slows the story down, treats its claims as constraints on one another, and forces anomalies to be classified rather than rhetorically absorbed.

canonical_formula: coherent_metanarrative = explicit_scope + claim_inventory + dependency_map + consistency_criteria + contradiction_log + boundary_exception_resolution

structural_problem: A comprehensive narrative is being used to explain events, justify decisions, stabilize identity, or organize interpretation, but its claims may conflict across levels, periods, exceptions, sources, or implied conclusions. Without an explicit coherence check, contradictions can remain hidden inside persuasive language.

trigger_conditions: A story explains too much too smoothly and absorbs anomalies without visible criteria.

trigger_conditions: Different parts of the narrative imply incompatible causal accounts, timelines, values, or actor roles.

trigger_conditions: A narrative is used to justify strategy, legitimacy, policy, identity, or evaluation decisions.

trigger_conditions: The narrative has accumulated revisions, exceptions, or rhetorical substitutions over time.

trigger_conditions: Critics point to contradictions but no shared audit structure exists for judging them.

trigger_conditions: A theory of change or institutional story links problem, cause, action, and outcome but its assumptions are not explicitly validated.

symptoms: Same term used with different meanings in different parts of the story.

symptoms: Exceptions are treated as proof of the narrative in one passage and ignored in another.

symptoms: A causal sequence requires events, actors, or capacities that the narrative elsewhere denies.

symptoms: Evidence supports local claims but not the global conclusion.

symptoms: Boundary conditions are unclear, so every counterexample is either dismissed or absorbed ad hoc.

symptoms: The narrative’s practical recommendations contradict its stated values or diagnosis.

symptoms: Revision history shows contradictions being renamed rather than resolved.

root_tension: Comprehensive narratives need enough breadth to integrate complexity, but that breadth makes it easy to hide contradictory claims, shifting meanings, and unsupported exceptions inside a persuasive whole.

anti_signatures: The task is only to verify isolated factual claims, not to test a broader narrative structure.

anti_signatures: The narrative is intentionally plural, paradoxical, poetic, or exploratory and is not being used as a coherent explanatory or decision warrant.

anti_signatures: The main issue is source authenticity rather than consistency among claims.

anti_signatures: The main issue is who benefits from the narrative or whether authority is justified; use narrative legitimacy critique as the primary archetype.

anti_signatures: The structure is a formal derivation with explicit premises and conclusions; use deductive chain validation unless narrative scope matters.

structural_intervention: Externalize the metanarrative into a claim-and-dependency structure, define consistency criteria, audit contradictions and exceptions, then revise scope, terms, claims, or narrative architecture until the story either coheres within stated limits or is rejected.

action_logic: State the narrative’s claimed scope, audience, purpose, timeframe, and explanatory ambition.

action_logic: Inventory core claims, causal links, values, terms, exceptions, and conclusions.

action_logic: Map dependencies among claims and identify which claims constrain others.

action_logic: Define consistency criteria before adjudicating disputes.

action_logic: Scan for contradictions, semantic shifts, unsupported exceptions, temporal or causal incompatibilities, and evidence-to-claim gaps.

action_logic: Classify tensions as acceptable complexity, ambiguity needing qualification, repairable contradiction, or fatal incoherence.

action_logic: Repair by narrowing scope, splitting the narrative, revising terms, adding distinctions, changing claims, or rejecting the narrative.

action_logic: Record the revision so future uses preserve the repaired boundaries and do not reintroduce hidden contradictions.

decision_rules: Draft as a full archetype when validation of internal coherence is the central intervention, not merely a substep of narrative construction or grand narrative decomposition.

decision_rules: Treat contradictions as fatal only when claims cannot jointly hold under the narrative’s own definitions and scope.

decision_rules: Preserve productive tension when the narrative explicitly represents multiplicity, ambiguity, or competing perspectives rather than claiming total coherence.

decision_rules: Use source-provenance or fact-checking mechanisms when evidence is disputed, but return to claim consistency after evidence status is established.

decision_rules: Escalate to legitimacy and authority critique when coherence is being used to mask power, exclusion, or constructed authority.

target_invariants: Major claims are explicit enough to test.

target_invariants: Key terms retain stable meaning or clearly marked semantic shifts.

target_invariants: Causal and temporal claims do not undermine one another.

target_invariants: Exceptions are classified rather than ignored or absorbed ad hoc.

target_invariants: Evidence links support the level of claim being made.

target_invariants: Revisions repair contradictions without erasing inconvenient evidence.

target_invariants: The narrative’s scope remains bounded to the cases it can coherently explain.

expected_outcomes: Contradictions and unsupported exceptions become visible and actionable.

expected_outcomes: Narratives become narrower, clearer, more defensible, or are rejected when incoherent.

expected_outcomes: Users distinguish persuasive fluency from validated coherence.

expected_outcomes: Narrative revisions preserve traceability and avoid rhetorical laundering.

expected_outcomes: Decision, scholarship, or strategy based on the narrative becomes less brittle.

prose_essence: A metanarrative coherence check turns a broad explanatory story into an auditable claim structure. It identifies the narrative’s scope, claims, causal sequence, terms, exceptions, evidence links, and implied conclusions, then tests whether they can all hold together. The goal is not to make the story smoother; it is to distinguish legitimate complexity from hidden contradiction.

prose_when_to_use:
Use this archetype when a comprehensive story is doing real work: explaining history, justifying strategy, stabilizing institutional identity, persuading an audience, or supporting a theory of change. It is especially useful when the story feels persuasive but critics, anomalies, revisions, or exceptions suggest that parts of it may not fit together.

Do not use it merely for isolated fact checking, copyediting, or legitimacy critique. If the core question is “who benefits from this story?” use narrative legitimacy and authority critique as the primary archetype. If the core question is “what assumptions and exclusions make this grand story possible?” use grand narrative decomposition first, then apply this archetype if coherence validation remains necessary.

prose_structural_problem: Broad narratives can hide contradictions because their claims are distributed across episodes, examples, values, causal links, and exceptions. A narrative may use the same term in multiple ways, treat anomalies inconsistently, claim causal necessity in one place and contingency in another, or use local evidence to support a global conclusion. Without a structured check, persuasive fluency substitutes for validation.

prose_intervention_logic: The intervention externalizes the story. First, state the narrative’s scope and purpose. Then inventory its core claims and map how they support, limit, or imply each other. Define what counts as contradiction, ambiguity, exception, or unresolved tension. Run consistency checks across claims, terms, causal sequences, evidence links, and boundaries. Finally, repair the narrative by narrowing scope, revising claims, adding distinctions, splitting the story, or rejecting it.

prose_key_components:
- **Metanarrative scope statement:** defines the narrative’s claimed domain, timeframe, actors, and explanatory ambition.
- **Core claim inventory:** lists descriptive, causal, normative, temporal, and identity claims.
- **Claim dependency map:** shows how claims support, imply, or constrain one another.
- **Consistency criteria:** define contradiction, scope creep, unsupported exception, and causal mismatch.
- **Evidence and source-link register:** ties major claims to evidence or interpretive warrants.
- **Contradiction and tension log:** records incompatibilities, ambiguities, and unresolved tensions.
- **Exception and boundary register:** separates legitimate boundary cases from disconfirming contradictions.
- **Reconciliation or revision plan:** specifies how the narrative should be repaired, narrowed, split, or rejected.

prose_common_mechanisms: Common mechanisms include claim-lattice mapping, contradiction scans, causal-temporal tracing, term-stability review, evidence-to-claim traceability, counter-narrative probes, exception classification, revision diff review, and red-team coherence review. These mechanisms are supports; the archetype is the full validation architecture that uses them together.

prose_failure_modes:
- **Rhetorical coherence mistaken for validation:** the story sounds smooth, so no claim-level audit occurs.
- **Overzealous contradiction hunting:** ambiguity or plural perspective is misclassified as incoherence.
- **Scope creep absorption:** counterexamples are absorbed without revising the core narrative.
- **Semantic drift laundering:** key terms change meaning to avoid contradiction.
- **Evidence-level mismatch:** local evidence is used to justify a global conclusion.
- **Revision without repair:** wording changes but the contradiction remains structurally present.
- **Coherence as legitimacy laundering:** internal consistency is mistaken for moral, political, or evidentiary legitimacy.

prose_neighbor_distinctions: `grand_narrative_decomposition` breaks sweeping stories into assumptions, actors, exclusions, and layers. This archetype validates whether the resulting claims cohere. `narrative_construction_audit` inspects event selection and causal storyline construction. This archetype checks consistency across the whole metanarrative. `deductive_chain_validation` checks formal premise-to-conclusion logic. This archetype handles mixed narrative systems containing evidence, values, periodization, identity, causality, and exceptions. `narrative_legitimacy_and_authority_critique` asks who benefits and whether authority claims are justified; this archetype asks whether the narrative can hold together under its own scope.

prose_cross_domain_examples: In historical scholarship, a progress narrative is checked against its own causal claims, period boundaries, exceptions, and omitted groups. In organizational strategy, a “customer-first transformation” story is tested against incentives, governance, and actual product decisions. In program evaluation, a theory of change is checked for missing causal links between activities, behavior change, and outcomes. In literary analysis, a comprehensive interpretation is tested against plot events, narrator reliability, and character motivation. In product communication, a “privacy-first personalization” narrative is checked against data retention and partner-sharing claims.

prose_non_examples: A communications team smoothing a story for public relations is not applying this archetype unless it exposes and repairs contradictions. A source-authenticity check is not this archetype unless source links are used to validate claim coherence. A formal theorem proof belongs under deductive validation unless it is part of a broader narrative warrant. A critique of who benefits from a national myth is primarily legitimacy and authority critique.

prose_tradeoffs: Strict coherence checks improve discipline but can flatten plural perspectives. Scope narrowing repairs consistency but reduces rhetorical power. Counter-narrative testing improves robustness but can become endless contestation. Evidence-linking improves validation but may create false confidence if sources are weak. Versioned revisions preserve learning but can make narratives less elegant.

prose_invariants_to_preserve: The audit should preserve explicit scope, stable terminology or marked semantic shifts, traceable evidence links, distinction between contradiction and complexity, accountable exception handling, and versioned repair. It should not erase tensions merely to make a story more persuasive.

prose_target_outcomes: A successful application makes hidden contradictions visible, narrows overbroad claims, clarifies exceptions, distinguishes unsupported leaps from defensible inference, and produces a narrative that is either more coherent or explicitly rejected. The result may be a less sweeping story, but it should be more defensible.

prose_parameter_dimensions: Tune the audit by narrative scope, claim granularity, strictness of consistency criteria, tolerance for ambiguity, evidence-link depth, number of counter-narratives, review independence, and revision threshold. A literary interpretation may tolerate more ambiguity than a policy theory of change. A public legitimacy narrative may require broader stakeholder review than an internal project story.

prose_variants_and_near_names: Recognized variants include grand narrative consistency audit, organizational story continuity check, plot and world continuity check, and theory-of-change coherence validation. Near names include narrative consistency check, metanarrative consistency audit, master narrative coherence review, story continuity check, and theory-of-change coherence validation. “Metanarrative Audit” is ambiguous because it already appears as an alias for `grand_narrative_decomposition`; use this archetype only when internal coherence validation is the primary move.

Grand Narrative Consistency Audit

short_definition: A broad audit of whether a master narrative’s claims, causal sequence, values, and exceptions remain mutually compatible.

distinctive_feature: Applies the parent pattern to highly totalizing narratives with multiple explanatory layers.

distinct_from_parent: Broader in scope and often more interpretive than localized narrative validation.

still_same_parent_because: It preserves the parent invariant: comprehensive narrative claims must be mutually compatible and scope-bounded.

use_when: A sweeping explanatory story is used to organize history, policy, strategy, or identity.

use_when: The narrative claims wide scope and faces anomalies or internal tensions.

example_domains:
historiography
ideology critique
organizational identity narratives

failure_modes: Treating complexity or plurality as contradiction without checking the narrative’s actual claim structure.

Organizational Story Continuity Check

short_definition: A variant that checks whether an organization’s founding story, strategy narrative, values claims, and actual evolution still fit together.

distinctive_feature: Uses organizational records, strategy shifts, and stakeholder claims to test narrative continuity.

distinct_from_parent: Specialized for institutional identity and strategy narratives.

still_same_parent_because: It validates internal coherence among narrative claims, evidence, and exceptions.

use_when: A company, institution, or movement relies on a public narrative of purpose, continuity, or transformation.

use_when: New decisions contradict the stated story or reveal unacknowledged drift.

example_domains:
corporate strategy
nonprofit mission review
public-sector reform

failure_modes: Converting coherence review into brand-polishing that hides contradictions instead of resolving them.

Plot and World Continuity Check

short_definition: A creative-domain variant that checks whether plot, character motivation, world rules, and prior events remain internally consistent.

distinctive_feature: Treats continuity and world rules as the coherence target.

distinct_from_parent: Narrower and often artifact-focused, but structurally similar.

still_same_parent_because: It validates an internally constructed narrative system against its own claims and constraints.

use_when: A fictional or designed world accumulates complex canon over time.

use_when: Audience trust depends on continuity of rules, motives, and consequences.

example_domains:
novel editing
film franchises
game lore design

failure_modes: Mistaking deliberate ambiguity or unreliable narration for inconsistency.

Theory-of-Change Coherence Validation

short_definition: A variant that checks whether an intervention’s problem story, causal pathway, metrics, and expected outcomes fit together.

distinctive_feature: Focuses on causal and evaluative consistency within action-oriented narratives.

distinct_from_parent: More operational and evaluative than general metanarrative review.

still_same_parent_because: It applies coherence validation to a comprehensive action narrative.

use_when: A program or strategy narrative justifies action through a causal theory.

use_when: Activities, assumptions, and metrics may contradict the stated theory.

example_domains:
program evaluation
policy design
grant strategy

failure_modes: Accepting a plausible story while ignoring inconsistent metrics, assumptions, or causal steps.

near_names:
Metanarrative Audit
Narrative Consistency Check
Master Narrative Coherence Review
Continuity Check
Contradiction Scan