1 - GROOVE_Grounded_Relations_Over_Observable_Versioned_Entries_Formal_Method_Specification_v1.0.docx

Text edition. See the original for figures and page layout.
GROOVE

GROOVE

Grounded Relations Over Observable Versioned Entries

A Lightweight Semantic Routing Method for AI-Readable Self-Documentation

CORE PROPOSITION

Document collections become easier for humans and AI systems to interpret when authors explicitly register a small number of high-value semantic relationships, source locations, and navigational handles instead of requiring future readers to reconstruct those relationships from content alone.

REFERENCE IMPLEMENTATION

A functional GROOVE can be built with folders, hyperlinks, one visible Excel working sheet, one hidden validation sheet, and AI-assisted document review.

Formal Method Specification v1.0

15 August 2026

Reference architecture: folder hierarchy + Excel GROOVE manifests + resolvable Entry Locators

Document Control

Table 1. Document control

Field

	Specification

	Specification name

	GROOVE — Grounded Relations Over Observable Versioned Entries

	Document type

	Formal Method Specification

	Version

	1.0

	Status

	Reference method / proposed standard

	Primary purpose

	AI-readable self-documentation and semantic routing across document collections

	Reference implementation

	Excel workbooks, folder hierarchy, and resolvable links

	Primary visible artifact

	00 - GROOVE.xlsx

	Corpus navigation artifact

	000 - GROOVE Master.xlsx

	Schema support artifact

	Hidden GROOVE_OPTIONS worksheet

	Provider requirement

	Provider-neutral; any storage system with usable Entry Locators

	Normative keywords

	MUST, MUST NOT, SHALL, SHALL NOT, SHOULD, SHOULD NOT, MAY, OPTIONAL

Normative Language

The terms MUST, MUST NOT, SHALL, SHALL NOT, SHOULD, SHOULD NOT, MAY, and OPTIONAL are used normatively. SHOULD expresses a strong recommendation that may be departed from when a deployment has a documented reason. MAY and OPTIONAL identify compatible extensions rather than requirements.

Terminology Note

GROOVE uses the term Entry for an observable versioned knowledge artifact and Entry Locator for a link or other resolvable address that can open, focus, or otherwise retrieve that Entry. In the Excel reference implementation, the visible column may simply be labeled URL or Link even when the locator resolves a local file, OneDrive item, SharePoint document, or another provider-specific resource.

Executive Summary

GROOVE is a lightweight self-documentation method for making the intended structure of a document collection explicit before a future reader or AI system has to infer that structure from content. The method assumes a simple fact: authors often already know which document is foundational, which document extends another, which specification owns a definition, which file supersedes an older one, and where an important relationship is expressed. When that knowledge is left only in the author’s memory, every future reader must repeatedly reconstruct the same map. GROOVE records the map once.

The reference architecture uses three documentation layers. A corpus-level 000 GROOVE Master routes readers to the correct System Understanding Bundle. A local 00 GROOVE manifest orients readers inside that Bundle by registering its Entries, their roles, their relationships, their locators, and natural-language descriptions of where important relationships occur. The numbered 01+ Entries remain the substantive source material. The hierarchy can therefore be summarized as ROUTE ME → ORIENT ME → GROUND ME.

The local GROOVE workbook is intentionally simple from the operator’s perspective: one visible working sheet. The visible sheet contains Bundle identity, a document registry, a relation table, optional boundaries, and optional reading paths. A hidden GROOVE_OPTIONS sheet carries the controlled relation vocabulary, document roles, review states, epistemic states, and schema version used by Excel data-validation dropdowns. This hidden sheet keeps the working surface simple while reducing metadata drift.

GROOVE is designed to work with AI rather than compete with it. AI may read an un-GROOVEd folder, propose roles and relations, identify likely source locations, and populate a draft GROOVE sheet. Those proposals remain distinguishable from reviewed GROOVE. Future AI can then use accepted relationships as semantic handles: open the correct Bundle, identify the relevant Entry, follow a typed relation, click the target locator, orient around a semantic location description, and inspect the actual source. The machine spends less effort reconstructing filing-system semantics and more effort understanding the substantive material.

FOUNDING RULE

If an important relationship is already known, do not force every future reader to rediscover it. Register the relationship once, preserve its direction and provenance, and let future parsing follow the groove.

Reading Map

Table 2. Reading map

Part

	Sections

	Focus

	Part I

	1–7

	Method foundations, formal definitions, and the 000 / 00 / 01+ convention

	Part II

	8–13

	Bundles, source Entries, locators, semantic landing orientation, and source authority

	Part III

	14–27

	Excel reference implementation, visible GROOVE sheet, hidden GROOVE_OPTIONS sheet, and controlled vocabularies

	Part IV

	28–31

	000 Master navigation, Bundle projections, and authority hierarchy

	Part V

	32–41

	GROOVE Build process and AI-assisted construction

	Part VI

	42–47

	AI routing, OneDrive reference implementation, search/embedding coexistence, and context assembly

	Part VII

	48–52

	Versioning, re-GROOVE, supersession, and impact analysis

	Part VIII

	53–57

	Formal principles, conformance, failure states, security, and anti-patterns

	Part IX

	58–62

	Worked examples

	Part X

	63–66

	Extensions, machine-learning uses, companion architecture, and conclusion

	Appendices

	A–F

	Reference sheet layouts, prompts, checklist, and glossary

PART I

METHOD FOUNDATIONS

1. Purpose and Scope

This specification defines GROOVE as a provider-neutral method for author-guided semantic routing across document collections. It specifies the minimum concepts needed to organize document Bundles, register high-value relationships, expose stable navigation handles, preserve version awareness, and support AI-assisted creation and use of the resulting maps.

The primary reference implementation is deliberately low-tech: folders plus Excel. The method does not require a vector database, knowledge graph platform, embedding service, custom application, or machine-learning pipeline. Such systems may consume GROOVE, but they are not prerequisites for conformance.

This paper defines the general method only. Native integration of GROOVE into a richer semantic registry, including registered Bundle objects, typed relation objects, context assembly, and native cross-system bridges, is intentionally left to a separate architecture.

1.1 In Scope

Corpus-level navigation through a 000 GROOVE Master.

Bundle-level semantic orientation through a 00 GROOVE manifest.

Document registration using number, title, version, role, description, and Entry Locator.

Directional document relations with source and target orientation descriptions.

Controlled vocabularies implemented through a hidden GROOVE_OPTIONS sheet.

Human-reviewed AI assistance for GROOVE construction and maintenance.

Version-aware relation review and re-GROOVE workflows.

Provider-neutral operation across OneDrive, SharePoint, Google Drive, local files, network drives, Git-hosted documents, or comparable systems.

1.2 Out of Scope

Replacing source documents with metadata summaries.

Defining a universal ontology for all possible knowledge relations.

Guaranteeing truth merely because a relation is registered.

Bypassing access control or storage-provider permissions.

Requiring exact paragraph-level anchors where semantic orientation is sufficient.

Treating AI-proposed relations as authoritative without an explicit review state.

Specifying a CERBERUS-native documentation registry; that belongs to the companion paper.

2. Problem Statement

Document archives often preserve content while losing structural intent. Folder containment can show that files are nearby. Filenames can hint at sequence. Search can find words. Embeddings can find semantic similarity. None of those mechanisms necessarily tells a future reader that one file is the canonical foundation, another is merely an application, a third requires the first, a later file supersedes only one bounded section, or two frequently co-occurring concepts must not be collapsed into one.

For a human author, these relations may feel obvious because they were present during creation. For a future collaborator, successor, or AI system, the same archive can require repeated reconstruction. The cost becomes especially visible in large self-authored systems where hundreds of documents share vocabulary, reuse abstractions, and evolve through versions.

DESIGN PROBLEM

How can an author preserve enough of the intended document topology that a future human or AI can start from the right semantic orientation without requiring a specialized knowledge-management platform?

3. Core Thesis

GROOVE treats author-known relationships as durable navigation infrastructure. The method does not attempt to precompute every possible answer. It records a small number of stable semantic handles that reduce ambiguity before reasoning begins. Those handles identify what an Entry is, how to open it, what role it plays, how it relates to another Entry, and approximately where that relationship is grounded.

CORE THESIS

GROOVE does not replace machine reasoning. It gives machine reasoning stable semantic handles from which to begin.

4. Design Goals

Table 3. GROOVE design goals

Goal

	Meaning

	Low implementation cost

	A useful deployment SHOULD be buildable with ordinary folders, Excel, and links.

	Human readability

	A nontechnical author SHOULD be able to inspect and edit the relation map directly.

	AI readability

	Fields SHOULD expose explicit identities, roles, directions, and locators rather than relying on visual placement alone.

	Thinness

	Metadata SHOULD orient source retrieval without duplicating the source.

	Version awareness

	Relations SHOULD identify when the Entries they were established against have changed materially.

	Provider independence

	The method SHOULD survive movement between document storage platforms where usable locators remain available.

	Progressive precision

	A deployment MAY begin at document-level relations and add finer location descriptions only where retrieval value justifies the work.

	Reviewability

	Machine-generated relation proposals SHOULD remain distinguishable from reviewed GROOVE.

5. Formal Definitions

Table 4. Formal definitions

Term

	Definition

	Observable Versioned Entry

	A knowledge artifact that can be opened or inspected and whose current revision can be distinguished from materially different revisions.

	System Understanding Bundle

	A bounded collection of Entries intended to be understood together as one system, topic, method, or architecture.

	GROOVE Manifest

	The local 00 workbook that registers Bundle identity, Entries, relations, locations, boundaries, and optional reading paths.

	GROOVE Master

	The corpus-level 000 workbook that lists Bundles and provides direct navigation to their folders and local manifests.

	Entry Handle

	A compact local identifier, normally the visible Number field, used to refer to an Entry inside a Bundle.

	Entry Locator

	A resolvable link or address that can retrieve, open, or focus an Entry.

	GROOVE Relation

	A typed, usually directional statement connecting a Source Entry to a Target Entry.

	Semantic Landing Orientation

	A natural-language description of where or why a relation is relevant inside an Entry.

	GROOVE Boundary

	An explicit prohibition against a plausible but invalid semantic collapse or inference.

	Reading Path

	An optional author-provided sequence of Entries useful for a bounded learning or retrieval intent.

	GROOVE_OPTIONS

	The hidden worksheet that stores controlled vocabularies, relation definitions, validation options, and schema version metadata.

	Re-GROOVE

	The review process by which existing metadata is revalidated after source Entries or Bundle structure change.

6. The 000 / 00 / 01+ Convention

The reference convention assigns meaning to leading zero layers. The convention is intentionally easy to remember and does not depend on any particular operating system or storage provider.

000 — GROOVE MASTER
Corpus navigation
ROUTE ME

↓

00 — GROOVE
Bundle semantic manifest
ORIENT ME

↓

01+ — OBSERVABLE VERSIONED ENTRIES
Specifications • notes • reports • data • code • diagrams
GROUND ME

	Figure 1. GROOVE progressive resolution. The 000 layer routes a reader to the appropriate System Understanding Bundle; the local 00 layer provides semantic orientation within that Bundle; numbered source Entries provide observable grounding.

The numbering convention is not the semantic identity of the source itself. A deployment MAY later introduce stable internal Entry IDs, but the visible 01, 02, 03 sequence is intentionally convenient for human reading and compact relation statements.

7. Before and After GROOVE

GROOVE is designed to require very little change to an existing folder. A deployment may begin by numbering files, adding a 00 workbook, and registering only the relationships that materially improve orientation.

BEFORE GROOVE

Learning/
├─ Foundation.docx
├─ Method.docx
├─ Application.docx
└─ Notes.pdf

Relationship structure lives largely in memory.

	AFTER GROOVE

Learning/
├─ 00 - GROOVE.xlsx
├─ 01 - Foundation.docx
├─ 02 - Method.docx
├─ 03 - Application.docx
└─ 04 - Notes.pdf

02 REQUIRES 01
03 APPLIES 01
04 BRIDGES_TO 02

	Figure 2. Folder before and after GROOVE. The source documents remain intact; GROOVE adds an explicit, navigable semantic map around them.

PART II

REFERENCE DOCUMENTATION ARCHITECTURE

8. System Understanding Bundles

A System Understanding Bundle groups Entries that are intended to be understood together. The Bundle may correspond to a product subsystem, research area, learning method, operating procedure, documentation family, or any other bounded knowledge domain. The key requirement is that the Bundle has a coherent purpose and a local GROOVE manifest.

A Bundle SHOULD be small enough that its local relation map remains comprehensible but large enough that the registered relations are useful. GROOVE does not prescribe a maximum number of Entries. If a Bundle becomes difficult to navigate, it MAY be split into nested Bundles, each with its own 00 manifest.

9. Observable Versioned Entries

The source Entry remains the authoritative object for its substantive content. GROOVE may summarize what the Entry does, but the summary is not a replacement for the Entry. The Entry can be a Word document, PDF, spreadsheet, slide deck, text file, code repository, dataset, image set, or other inspectable artifact.

Version awareness is part of the method name because relationships can become stale when source material changes. A deployment SHOULD record a meaningful version or revision label whenever the relationship between Entries depends on content that can evolve.

10. Entry Numbering, Titles, and Roles

The reference implementation uses local Number values such as 01, 02, and 03 because they are compact, readable, and useful inside relation statements. The Number SHOULD be treated as a local Bundle handle rather than a globally unique semantic identity.

Table 5. Recommended document registry fields

Field

	Purpose

	Example

	Number

	Compact local handle

	03

	Title

	Human-readable identity

	REUSE Method

	Version

	Revision context

	1.1

	Role

	What the Entry does in the Bundle

	METHOD

	Status

	Lifecycle state

	ACTIVE

	Description

	Short orientation summary

	Extends learning with prior-knowledge reuse

	URL / Link

	Resolvable Entry Locator

	OPEN

11. Entry Locators

An Entry Locator is any address that lets the consuming system resolve the source. In the reference Excel build, the visible field can be labeled URL Link because hyperlinks are convenient and familiar. The semantic contract is broader: the link may open a web document, focus an already-open OneDrive item, open a local file, route to a SharePoint resource, navigate to a Git-hosted specification, or invoke a future document runtime.

LOCATOR RULE

GROOVE requires resolvability, not a particular storage provider. The visible URL column is an implementation convenience, not a protocol dependency.

12. Semantic Landing Orientation

GROOVE does not require brittle page-and-paragraph coordinates. Instead, a relation MAY record a natural-language location description that tells a human or AI what to search for after the target Entry is opened. This description should use stable concepts, headings, or distinctive phrases whenever possible.

Table 6. Semantic landing orientation examples

Weak orientation

	Preferred semantic orientation

	Page 43, paragraph 7

	Evidence-Governed Learner Status — evidence classes and transition requirements

	Second chart

	IR operational geometry — weld path and frame example

	Near the end

	Version review — stale relation detection and revalidation

	Section 4.2 only

	Relation Table — Source, Relation, Target, and location fields

Exact anchors MAY still be used when the storage provider supports stable deep links. The method deliberately permits coarser semantic orientation because a resilient description is often more useful than a locator that breaks whenever pagination changes.

13. Source Authority

GROOVE metadata explains how to approach a source; it does not become a substitute source. If a relation description and the underlying Entry conflict, the reader SHOULD inspect the Entry and treat the mismatch as a GROOVE review condition.

SOURCE AUTHORITY PRINCIPLE

GROOVE points. The Entry proves.

PART III

EXCEL REFERENCE IMPLEMENTATION

14. The 00 GROOVE Workbook

The local reference workbook is named 00 - GROOVE.xlsx. Its ordinary user-facing experience SHOULD consist of one visible working sheet named GROOVE. A second sheet named GROOVE_OPTIONS SHOULD be hidden during normal use and used only to support controlled vocabularies, validation lists, definitions, and schema version metadata.

15. One-Visible-Sheet Principle

GROOVE intentionally favors one coherent working surface over a workbook containing many independent operational tabs. The visible sheet MAY contain several Excel Tables arranged vertically, but the user should be able to scroll through the Bundle identity, document registry, relations, boundaries, and reading paths without navigating between multiple visible sheets.

USABILITY OBJECTIVE

A person should be able to understand the local Bundle map by opening one workbook and reading one visible sheet.

16. Visible GROOVE Sheet Layout

Reference GROOVE working surface

#

	Title

	Version

	Role ▼

	Status ▼

	Description

	URL

	01

	Foundation Specification

	1.0

	FOUNDATION

	ACTIVE

	Establishes core system semantics

	OPEN

	02

	Institutional Application

	1.0

	APPLICATION

	ACTIVE

	Applies 01 in an institutional setting

	OPEN

	03

	Reuse Method

	1.1

	METHOD

	ACTIVE

	Adds prior-knowledge reuse logic

	OPEN

	04

	Context Resolution

	1.0

	INFRASTRUCTURE

	ACTIVE

	Provides bounded relation resolution

	OPEN

Figure 3. Reference GROOVE visible sheet — document registry region. Controlled fields use dropdowns while Number, Title, Description, and URL provide simple human and machine handles.

Reference GROOVE relation region

Source

	Relation ▼

	Target

	Scope

	Source Location

	Target Location

	Why / Description

	Review ▼

	03

	REQUIRES

	01

	Learner state

	Prior Knowledge Resolution

	Evidence-Governed Status

	Reuse assumes verified learner state defined in 01

	VERIFIED

	03

	USES

	04

	Bridge resolution

	Transfer eligibility

	SCREEN/CALL definitions

	04 supplies bounded registered semantic bridges

	VERIFIED

	02

	INSTANTIATES

	01

	Institutional use

	Academy learning model

	Core learning architecture

	02 realizes the learning architecture institutionally

	REVIEWED

Figure 4. Reference GROOVE visible sheet — relation region. A relation row combines compact identity, typed direction, semantic location, explanation, and review state.

17. Bundle Metadata Region

Table 7. Recommended Bundle metadata

Field

	Recommended content

	Bundle Number

	Local corpus handle used by the 000 Master

	Bundle Name

	Human-readable system or topic name

	Bundle Version

	Version of the local GROOVE manifest

	Purpose

	One-paragraph statement of what the Bundle contains

	Folder Link

	Direct locator to the folder or container

	Foundation Entry

	Entry that most strongly establishes the Bundle’s baseline semantics, if one exists

	GROOVE Schema

	Schema version expected by the workbook

	Last Reviewed

	Date on which the manifest was last intentionally reviewed

18. Document Registry

The Document Registry is the simplest part of GROOVE and often the most immediately useful. Every registered source Entry receives a compact Number, title, version, role, lifecycle status, description, and locator. Additional fields MAY be added, but the visible schema SHOULD remain small enough that a reader can scan the entire Bundle quickly.

The Registry enables relation rows to reference Source 03 and Target 01 without repeating long filenames. It also gives AI a stable expansion path: local handle → title → role → locator → observable source.

19. GROOVE Relation Table

The relation table is the core semantic structure. Each row represents one declared relationship. The relation is normally directional: Source REQUIRES Target does not imply that Target REQUIRES Source. GROOVE therefore records the relation from the perspective that matters for interpretation.

Table 8. Reference relation fields

Field

	Meaning

	Source #

	Local Entry handle from which the relation is asserted

	Relation

	Controlled relation type selected from GROOVE_OPTIONS

	Target #

	Local Entry handle to which the relation points

	Scope

	Bounded area in which the relation applies

	Source Location

	Where the relation is relevant in the Source Entry

	Target Location

	Where the supporting or required semantics live in the Target Entry

	Relation Description

	Human-readable explanation of why the edge exists

	Review State

	PROPOSED, REVIEWED, VERIFIED, STALE, or RETIRED

	Source URL

	Optional direct convenience link to Source

	Target URL

	Optional direct convenience link to Target

20. Anatomy of One GROOVE Relation

SOURCE
03 — Reuse Method
OPEN

	REQUIRES

Why:
Reuse depends on verified learner-state semantics.

	TARGET
01 — Learning Specification
OPEN

	Source Location
Prior Knowledge Resolution

	Review State
VERIFIED

	Target Location
Evidence-Governed Learner Status

	Figure 5. Anatomy of one GROOVE relation. A single row can provide identity, direction, rationale, semantic landing orientation, navigation, and review state.

21. Boundary Table

A GROOVE Boundary records a tempting but invalid interpretation. Boundaries are especially useful for AI because models can collapse terms that frequently co-occur even when the source architecture intentionally keeps them distinct.

Table 9. Example GROOVE boundaries

Source / Concept

	Boundary

	Target / Concept

	Reason

	Projection

	DO_NOT_INFER

	Canonical State

	Projection represents state; it does not silently redefine it.

	Mastery Status

	DO_NOT_INFER

	Professional Credential

	Internal learning evidence does not establish external authorization.

	Entry Similarity

	DO_NOT_INFER

	Dependency

	Semantic similarity alone does not prove REQUIRES or EXTENDS.

22. Reading Paths

Reading Paths are optional traversal hints for recurring intents. They do not replace relation-level reasoning and do not imply that the path is the only valid order. A path simply records that the author already knows a useful route through the Bundle for a bounded purpose.

Table 10. Example reading paths

Path

	Step

	Entry

	Purpose

	URL

	Foundation

	1

	01

	Establish core semantics

	OPEN

	Foundation

	2

	03

	Understand reuse method

	OPEN

	Foundation

	3

	04

	Understand bounded relation resolution

	OPEN

	Institutional

	1

	01

	Core semantics

	OPEN

	Institutional

	2

	02

	Institutional application

	OPEN

23. Hidden GROOVE_OPTIONS Sheet

The hidden options sheet is the implementation mechanism that lets the visible sheet remain simple. It SHOULD contain the canonical dropdown values used by the workbook and SHOULD be hidden during ordinary use. It MAY be unhidden for schema inspection, extension, or maintenance.

VISIBLE: GROOVE

Role ▼
Status ▼
Relation ▼
Review ▼

Ordinary working surface

	HIDDEN: GROOVE_OPTIONS

RELATIONS
ROLES
DOCUMENT STATUS
RELATION REVIEW
EPISTEMIC STATUS
SCHEMA VERSION

Feeds Excel Data Validation

	Figure 6. Hidden validation sheet pattern. GROOVE_OPTIONS carries the schema vocabulary while the visible sheet exposes only simple dropdown fields.

24. Controlled Relation Vocabulary

Table 11. Core GROOVE relation vocabulary

Relation

	Definition

	Direction

	FOUNDATION_FOR

	Source establishes concepts or structure on which Target is built.

	Directional

	REQUIRES

	Source assumes concepts, data, or structures established by Target.

	Directional

	EXTENDS

	Source adds semantics or functionality to Target without replacing it.

	Directional

	USES

	Source consumes or invokes a mechanism defined by Target.

	Directional

	APPLIES

	Source applies Target in another bounded context.

	Directional

	INSTANTIATES

	Source realizes an abstract structure or method defined by Target.

	Directional

	SPECIALIZES

	Source narrows Target for a more specific domain or use.

	Directional

	CONSTRAINS

	Source limits valid interpretation or operation of Target.

	Directional

	VALIDATES

	Source supplies testing, evidence, or confirmation relevant to Target.

	Directional

	BRIDGES_TO

	Source establishes an explicit cross-system connection to Target.

	Directional

	SUPERSEDES

	Source replaces Target within a declared scope.

	Directional

	EXAMPLE_OF

	Source is a worked instance or demonstration of Target.

	Directional

	PARALLELS

	Source and Target share meaningful structure without an asserted dependency.

	Declared / often symmetric

	DO_NOT_INFER

	Explicitly prohibits a plausible but invalid semantic collapse.

	Boundary

Deployments MAY extend this vocabulary. New relation types SHOULD be added to GROOVE_OPTIONS with a definition and directionality rather than typed ad hoc into individual relation cells. If no registered relation fits, the user or AI SHOULD flag the need for review instead of silently inventing a near-synonym.

25. Controlled Roles and Statuses

Table 12. Reference controlled vocabularies

Vocabulary

	Reference values

	Entry Role

	FOUNDATION; SPECIFICATION; METHOD; EXTENSION; APPLICATION; IMPLEMENTATION; INFRASTRUCTURE; REFERENCE; CASE_STUDY; EXAMPLE

	Document Status

	DRAFT; ACTIVE; SUPERSEDED; DEPRECATED; ARCHIVED

	Relation Review

	PROPOSED; REVIEWED; VERIFIED; STALE; RETIRED

	Epistemic Status

	ESTABLISHED; DEVELOPING; EXPERIMENTAL; HYPOTHESIS; FANTASY

	Importance

	CORE; HIGH; NORMAL; OPTIONAL

Document Status and Epistemic Status SHOULD remain separate. A current ACTIVE document may describe FANTASY or EXPERIMENTAL material. Conversely, a SUPERSEDED document may have represented established knowledge at the time it was authored. GROOVE should not collapse lifecycle status into truth status.

26. Excel Data Validation

The reference Excel build SHOULD implement dropdowns using named ranges or equivalent table references backed by GROOVE_OPTIONS. The purpose is not to make Excel sophisticated; it is to make ordinary editing consistent. The user selects REQUIRES from a list instead of typing requires, depends on, needs, reliant on, or similar variants that fragment the relation vocabulary.

IMPLEMENTATION GUIDANCE

Prefer constrained dropdowns for fields that function as semantic vocabulary. Prefer free text for descriptions, locations, rationale, and human notes.

27. GROOVE Schema Versioning

The hidden sheet SHOULD record a GROOVE Schema Version and relation-vocabulary version. This allows future tooling to recognize which columns, dropdown values, and relation definitions are expected. A schema upgrade SHOULD NOT silently reinterpret existing relation values without an explicit migration or review step.

PART IV

000 MASTER NAVIGATION

28. The 000 GROOVE Master

The 000 workbook is the intentionally simple front door for the entire documentation corpus. Its purpose is corpus navigation, not local semantic authority. It tells the reader which System Understanding Bundles exist, what they broadly contain, and where to open each folder and 00 manifest.

29. 000 INDEX Sheet

Reference 000 INDEX

#

	System Understanding Bundle

	Purpose

	Folder

	00 GROOVE

	Foundation

	Key Contents

	01

	Semantic Core

	Core identity and relation architecture

	OPEN

	OPEN

	01 Foundation

	Identity, models, relations

	02

	Physical Landmarks

	Machine-readable spatial semantics

	OPEN

	OPEN

	01 Specification

	Landmarks, frames, profiles

	03

	Robotics

	Bounded robotics architecture

	OPEN

	OPEN

	01 Robotics Spec

	Capabilities, tasks, verification

	04

	Learning

	Learning and institutional architecture

	OPEN

	OPEN

	01 Learning Spec

	Learning, reuse, Academy

Figure 7. GROOVE Master Navigation. The corpus-level workbook exposes an intentionally simple list of Bundles with direct links to their folders and local 00 manifests.

30. Per-Bundle Sheets in 000

The 000 workbook MAY contain one shallow projection sheet for each Bundle in addition to the first 000 INDEX sheet. Each Bundle sheet can list the local 00 manifest and its numbered Entries with short roles and links. These sheets are convenience projections only; the local 00 workbook remains the canonical Bundle relation map.

000 - GROOVE Master.xlsx

Tabs:
000 INDEX  |  001 Semantic Core  |  002 Physical Landmarks  |  003 Robotics  |  004 Learning

Each Bundle tab:
00 GROOVE → 01 Foundation → 02 Extension → 03 Method → ...

	Figure 8. Nested workbook navigation. The 000 workbook provides corpus and Bundle-level convenience views while each local 00 workbook owns the detailed relation map.

31. Authority Hierarchy

Table 13. GROOVE authority hierarchy

Layer

	Authority

	01+ Observable Entry

	Owns substantive source content.

	00 Local GROOVE

	Owns the Bundle-level declared relationship map and semantic orientation metadata.

	000 GROOVE Master

	Owns corpus-level navigation and shallow Bundle summaries only.

A discrepancy SHOULD be resolved from the bottom upward: inspect the source Entry first, then correct the local 00 relation map, then refresh any 000 projection that depends on the changed Bundle metadata.

PART V

GROOVE BUILD PROCESS

32. Overview

GROOVE is designed to be created incrementally. An author does not need to annotate every paragraph or invent a complete ontology before benefiting from the method. The recommended first pass registers only the high-value structure already known by the people who created or maintain the documents.

33. Step 1 — Organize

Place related source Entries into a bounded folder or logical container. Choose a Bundle name and purpose. Number the local source files consistently enough that Number values can function as compact handles.

34. Step 2 — Register

Populate the Document Registry with Number, Title, Version, Role, Status, Description, and URL or other Entry Locator. If the storage system permits stable links, use direct locators to the source rather than links only to the parent folder.

35. Step 3 — Observe

Read the actual Entries. When AI is used, it SHOULD inspect the source documents rather than rely on filenames or old summaries. The goal is to identify what each Entry actually contributes and where important cross-document relationships are expressed.

36. Step 4 — Propose Relations

Create relation candidates for important dependencies, extensions, applications, examples, validations, bridges, supersessions, parallels, and boundaries. Prefer a small number of high-value relations over exhaustive linkage. A relation is valuable when it materially changes how a future reader should approach the documents.

37. Step 5 — Locate and Orient

For each high-value relation, add Source Location and Target Location descriptions where they reduce search cost. The description SHOULD be specific enough to orient retrieval but stable enough to survive ordinary edits. Exact anchors MAY be added later if the storage environment supports them reliably.

38. Step 6 — Review

AI-proposed relations SHOULD initially be marked PROPOSED. A human reviewer can accept, rewrite, reject, or supplement them. REVIEWED indicates intentional human inspection. VERIFIED may be used when the deployment has explicitly checked that the relationship remains supported by the declared source and target content.

REVIEW BOUNDARY

AI inference is not GROOVE merely because it was written into a spreadsheet. The review state must remain visible.

39. Step 7 — Commit and Route

Once reviewed, save the 00 workbook beside the Bundle. Add any useful Reading Paths and Boundaries. Then register the Bundle in the 000 Master with its purpose, folder link, local GROOVE link, foundation Entry, and high-level contents.

40. AI-Assisted GROOVE Build

UN-GROOVEd FOLDER
01  •  02  •  03  •  04

↓ AI OBSERVATION
Read Entries • identify roles • compare semantics • find dependencies • locate relevant sections

↓ PROPOSED GROOVE
Relations • locations • paths • boundaries

↓ HUMAN REVIEW
Accept • edit • reject • add

↓ REVIEWED 00 - GROOVE.xlsx

↓ FUTURE AI
Uses registered handles for faster, better-oriented source retrieval

	Figure 9. AI-assisted GROOVE Build. AI can accelerate observation and relation proposal, but human review remains an explicit transition before inferred structure becomes reviewed GROOVE.

41. Minimal First-Pass GROOVE

A first-pass GROOVE SHOULD focus on the following handles before adding finer detail: Bundle identity, Entry registry, foundational Entry, directional dependencies, canonical source ownership where obvious, version relationships, important DO_NOT_INFER boundaries, and one or two useful reading paths. This keeps GROOVE from becoming its own metadata-maintenance project.

PART VI

AI ROUTING AND RETRIEVAL

42. Semantic Handle Chain

CORPUS HANDLE
000 Master
→
BUNDLE HANDLE
System / folder
→
ENTRY HANDLE
Number + Title + Role
→
RELATION HANDLE
03 REQUIRES 01
→
LOCATOR HANDLE
URL / Entry Locator
→
ORIENTATION HANDLE
“Evidence-Governed Learner Status”
→
OBSERVABLE SOURCE
Actual Entry content

	Figure 10. Semantic Handle Chain. GROOVE progressively reduces ambiguity from corpus selection to local source inspection without replacing the source or the reasoning process.

43. GROOVE Navigation Protocol

1.  If the relevant Bundle is unknown, open the 000 GROOVE Master.

2.  Identify the Bundle whose purpose and contents best match the user’s intent.

3.  Open the Bundle folder or, preferably, its local 00 GROOVE manifest.

4.  Inspect the Document Registry, relation rows, Boundaries, and relevant Reading Paths.

5.  Resolve the Entry handle and relation that best explain why the target source matters.

6.  Follow the Entry Locator to open or focus the target document.

7.  Use the Semantic Landing Orientation to search or navigate locally inside the Entry.

8.  Read the surrounding source context before answering or transforming the information.

9.  Follow additional GROOVE edges only when needed for the current bounded task.

44. OneDrive Reference Implementation

OneDrive and SharePoint are convenient reference environments because individual files and folders can expose shareable or organization-scoped URLs. A GROOVE workbook stored beside the source files can therefore contain direct links that open or focus the relevant Entry. The method remains the same if the links point elsewhere.

USER QUESTION
“How does Method 03 depend on Foundation 01?”

↓
000 GROOVE MASTER
Question belongs to Learning Bundle

↓
00 GROOVE
03 REQUIRES 01

↓
TARGET URL — OPEN 01

↓
ONEDRIVE / DOCUMENT VIEW
Focus source Entry

↓
TARGET LOCATION
“Learner Status / evidence transitions”

↓
AI READS LOCAL CONTEXT → GROUNDED ANSWER

	Figure 11. Reference AI navigation through a linked folder system. OneDrive is illustrative; the same Entry Locator contract can be implemented by another storage provider.

45. Opening and Focusing

GROOVE does not require a distinction between opening a closed document and focusing an already-open one. The consuming runtime SHOULD treat the locator as a request to resolve the Entry. The storage provider, browser, desktop application, or future agent environment may then decide whether to open a new view, activate an existing tab, or otherwise make the source available.

46. GROOVE with Search and Embeddings

GROOVE is complementary to ordinary retrieval. Search is useful for locating phrases or terms. Embeddings are useful for similarity-based recall. GROOVE contributes a different signal: the author’s declared interpretation of how artifacts fit together.

Table 14. GROOVE alongside common retrieval mechanisms

Mechanism

	Primary question answered

	Folder hierarchy

	What is contained where?

	Keyword / full-text search

	Where does this phrase or term appear?

	Embeddings / semantic search

	What content appears semantically similar?

	GROOVE

	How does the author intend these Entries to relate, and where should a reader begin?

A strong AI workflow MAY combine all of them: use 000/00 to establish the intended system context, use GROOVE relations to identify authoritative and dependent Entries, then use search or embeddings locally within the bounded source set.

47. Context Assembly

GROOVE can reduce context-window waste by letting an AI assemble only the documents needed for a bounded question. A relation row can direct the model to a target Entry and location without forcing it to ingest the entire archive. A Reading Path can provide a known multi-document route. A Boundary can prevent the assembled context from collapsing adjacent concepts.

ROUTING PRINCIPLE

Route precisely enough to eliminate unnecessary inference, but leave enough local freedom for the reader to inspect the source in context.

PART VII

VERSIONING AND MAINTENANCE

48. Versioned Entries

The V in GROOVE matters because document relations are not timeless. A method may be rewritten. A specification may split. A foundation may acquire a new definition. A previously correct Source Location may no longer contain the relation it once described. The manifest therefore needs enough version awareness to detect when review is warranted.

49. Relation Review after Change

When an Entry changes materially, the owner SHOULD identify relation rows in which that Entry appears as Source or Target. AI can assist by comparing the new source text against the recorded location descriptions and relation rationale. The machine may suggest that a relation remains valid, moved, changed scope, or appears stale; the review state SHOULD not change silently without the deployment’s chosen authorization process.

50. Re-GROOVE

ENTRY v1.0
↓
GROOVE VERIFIED
↓
ENTRY EDITED → v1.1
↓
AI / HUMAN RELATION REVIEW
↓
VALID ─────────── POSSIBLY STALE
  │                    │
retain              inspect / update
  └──────────────┬─────┘
                 ↓
UPDATED GROOVE

	Figure 12. Re-GROOVE maintenance loop. Version changes trigger relation review rather than silent inheritance of old metadata.

51. Supersession and Archive

SUPERSEDES SHOULD be scoped. A new Entry may replace an older document entirely, or only within a bounded topic. GROOVE SHOULD preserve the older Entry’s version history rather than deleting evidence that prior documents existed. Archived or superseded Entries MAY remain linked when historical context is useful.

52. Impact Analysis

Once relations are explicit, even a simple spreadsheet can support change impact analysis. A maintainer can filter all rows where a changed Entry appears as Target and immediately see which methods, applications, paths, and external bridges may require review. This is one of the practical benefits of writing author-known dependencies down rather than leaving them implicit.

PART VIII

FORMAL PRINCIPLES AND CONFORMANCE

53. Formal Principles

Table 15. GROOVE formal principles

Principle

	Normative statement

	Observable Grounding Principle

	GROOVE metadata SHALL ultimately route to observable source Entries rather than substitute for them.

	Known-Relation Principle

	When an author already knows an important relationship among Entries, that relation SHOULD be registered rather than repeatedly delegated to future inference.

	Directional Relation Principle

	Relations SHALL preserve direction wherever direction changes interpretation.

	Thin Metadata Principle

	GROOVE SHOULD provide enough semantic structure to orient retrieval without duplicating the substantive source content.

	Controlled Vocabulary Principle

	Common relation and status fields SHOULD use bounded selectable vocabularies to reduce semantic drift.

	Semantic Landing Principle

	Human-readable source-location descriptions MAY be used to orient readers where exact technical anchors would be unnecessarily brittle.

	Human Review Principle

	Machine-proposed relations SHALL remain distinguishable from reviewed or verified GROOVE relations.

	Version Awareness Principle

	GROOVE SHOULD retain sufficient version information to identify when relationships may require revalidation.

	Progressive Resolution Principle

	GROOVE SHOULD support traversal from corpus to Bundle to Entry to relation to source location.

	Provider Independence Principle

	GROOVE SHALL NOT require a specific storage provider where equivalent resolvable Entry Locators are available.

	Source Authority Principle

	GROOVE points. The Entry proves.

	Permission Preservation Principle

	A GROOVE link SHALL NOT be treated as authorization to access content unavailable to the current user or system.

	Non-Exhaustiveness Principle

	Conformance SHALL NOT require authors to enumerate every possible relation among Entries; GROOVE is allowed to remain intentionally thin.

	Reviewable Extension Principle

	Custom vocabularies MAY be added when the extension is documented in GROOVE_OPTIONS and does not silently redefine existing relation names.

54. Conformance Levels

Table 16. Reference GROOVE conformance levels

Level

	Requirements

	Level 0 — Indexed

	Bundle folder contains numbered Entries and a 00 workbook with a Document Registry and working locators.

	Level 1 — Related

	Level 0 plus typed Source → Relation → Target rows with explanations for high-value relations.

	Level 2 — Oriented

	Level 1 plus Source/Target location descriptions, controlled vocabularies, and visible review states.

	Level 3 — Routed

	Level 2 plus 000 corpus navigation, optional Reading Paths, Boundaries, and version-review procedures.

	Level 4 — Maintained

	Level 3 plus active re-GROOVE review after material version changes and documented schema/vocabulary versioning.

55. Failure and Ambiguity States

Table 17. Reference failure and ambiguity states

State

	Meaning / response

	UNKNOWN_ENTRY

	Referenced Number or locator cannot be resolved. Do not guess another file.

	BROKEN_LOCATOR

	Entry is registered but its URL or locator no longer resolves.

	RELATION_UNSUPPORTED

	Current source text does not appear to support the registered relation. Flag for review.

	LOCATION_STALE

	Relation may remain valid, but recorded Source or Target location appears to have moved.

	VERSION_MISMATCH

	Relation was established against a materially different Entry version.

	RELATION_AMBIGUOUS

	Available vocabulary does not cleanly represent the intended relationship. Review or extend GROOVE_OPTIONS.

	PERMISSION_DENIED

	Locator resolves to protected content that the current reader cannot access.

	PROPOSED_ONLY

	Relation was machine-proposed or draft-only and has not reached the deployment’s reviewed state.

	CONFLICTING_GROOVE

	Two reviewed rows assert incompatible relations or authority claims. Inspect source and reconcile.

56. Security and Permissions

GROOVE can expose the existence, title, relation, or locator of a document even when the source itself is protected. Deployments SHOULD therefore treat manifest visibility as part of their information-security model. Sensitive Bundles MAY use restricted manifests, redacted descriptions, or permission-scoped 000 projections. A link in GROOVE does not bypass the underlying provider’s authorization controls.

57. Anti-Patterns

Using GROOVE summaries as a replacement for reading the source document.

Allowing each user or AI to invent relation synonyms in free text.

Treating semantic similarity as proof of REQUIRES, EXTENDS, or SUPERSEDES.

Copying local GROOVE relation details into 000 and maintaining two competing canonical maps.

Using page coordinates as the only location mechanism when ordinary editing constantly changes pagination.

Marking AI-generated relations VERIFIED without a defined review transition.

Attempting to link every paragraph to every other paragraph before any demonstrated retrieval need exists.

Assuming an ACTIVE document is epistemically established or that an EXPERIMENTAL document is merely a draft.

PART IX

WORKED EXAMPLES

58. Worked Example — Converting an Ungrooved Folder

Assume a folder contains four files: a foundation specification, a method that depends on the foundation, an institutional application, and a context-resolution specification used by the method. The author already knows these roles, but a new reader sees only filenames.

1.  Rename or number the files 01 through 04 without changing their substantive content.

2.  Create 00 - GROOVE.xlsx beside them.

3.  Register Number, Title, Version, Role, Status, Description, and Link for all four Entries.

4.  Add 03 REQUIRES 01 because the method assumes the foundation’s learner-state semantics.

5.  Add 03 USES 04 because the method consumes bounded semantic bridge resolution.

6.  Add 02 INSTANTIATES 01 because the institutional paper applies the foundation architecture.

7.  Add natural-language Source and Target Location descriptions for the three relations.

8.  Mark AI-generated rows PROPOSED until reviewed, then promote the accepted rows according to local review practice.

9.  Register the Bundle in 000 - GROOVE Master.xlsx.

59. Worked Example — AI Question Routing

A user asks, “How does Method 03 depend on Foundation 01?” A GROOVE-aware AI does not begin by globally searching every file. It reads the local relation map, finds 03 REQUIRES 01, sees that the scope is learner state, follows the Target URL to 01, searches or navigates to the Target Location description, reads the surrounding source, and answers from the actual Entry. If the Entry contradicts the relation metadata, the system flags the relation rather than forcing the source to fit the map.

60. Worked Example — Version Change

Entry 01 moves from version 1.0 to 1.1 and restructures its learner-state section. The relation 03 REQUIRES 01 is still conceptually valid, but the recorded Target Location no longer matches the current headings. The re-GROOVE process preserves the relation, updates the Target Location, records the new reviewed version context, and leaves a trace that the metadata was revalidated after the source change.

61. Worked Example — 000 Master Routing

A corpus contains dozens of folders. An AI receives a question about physical landmark verification but does not know which Bundle owns the concept. It opens 000, identifies the Bundle whose purpose mentions machine-readable spatial semantics, opens that Bundle’s 00 manifest, and then resolves the specific source Entry and relation. The 000 workbook has done no deep reasoning; it has merely prevented the model from starting in the wrong folder.

62. GROOVE Compared with Blind Retrieval

Blind retrieval is not always wrong. Modern search systems are often very good at finding relevant text. GROOVE changes the starting condition by adding authorial structure. A system can know not only that two files are similar, but that one is foundational, the other requires it, the target concept lives in a named section, and the relation was reviewed against particular versions. That additional orientation is especially valuable when a corpus reuses vocabulary across many layers.

PART X

EXTENSION BOUNDARIES AND CONCLUSION

63. Provider-Neutral Extensions

A compliant implementation may replace Excel with another tabular interface, generate the visible sheet from a database, use bookmarks for direct anchors, or automate the 000 projections. The general method remains GROOVE when the implementation preserves observable source grounding, explicit relations, version awareness, resolvable locators, and the distinction between proposed and reviewed metadata.

64. Machine Learning Uses

Reviewed GROOVE relations can function as labeled relational data. A research system could compare model-inferred relations with author-reviewed relations to evaluate dependency inference, canonical-source detection, supersession detection, context routing, false-equivalence avoidance, or relation classification. The paper does not require such training use, but the structure makes it possible without changing the documentation workflow.

The important distinction is that GROOVE is useful before any training occurs. The primary value comes from making the archive itself more legible. Machine-learning applications are optional downstream consumers of the same reviewed semantic handles.

65. Companion Architecture

A companion paper may integrate GROOVE into a native semantic documentation architecture in which Bundles, Entries, relations, versions, concept ownership, reading paths, and cross-system bridges become first-class registered objects. That architecture can use the Excel method as a simple projection or bootstrap surface while preserving the general GROOVE semantics defined here.

66. Conclusion

GROOVE begins from a modest observation: much of the structural intelligence needed to understand a document archive already exists in the author’s head. A folder system normally preserves the files but not that intelligence. GROOVE captures the small set of relationships that matter most—what the Entries are, how they connect, why the connection matters, where to look, which version was reviewed, and how to open the source.

The method deliberately keeps the source documents primary. The 000 Master routes. The local 00 manifest orients. The 01+ Entries ground. A hidden validation sheet constrains the vocabulary without complicating the visible build. AI can help generate and maintain the map, but reviewed relations remain visibly distinct from machine proposals. This combination provides a practical form of author-guided context resolution that can be implemented with ordinary office tools and scaled later into richer semantic infrastructure.

FINAL PRINCIPLE

Do not make the AI rediscover the map every time. Give it handles into the map — then let the observable sources do the proving.

APPENDICES

REFERENCE SCHEMAS AND PROMPTS

Appendix A — Reference 00 GROOVE Sheet Layout

Table A1. Reference visible sheet layout

Region

	Recommended columns / fields

	Bundle Metadata

	Bundle Number; Bundle Name; Bundle Version; Purpose; Folder Link; Foundation Entry; GROOVE Schema; Last Reviewed

	Document Registry

	Number; Title; Version; Role; Status; Epistemic Status; Description; URL Link

	Relations

	Source #; Relation; Target #; Scope; Source Location; Target Location; Relation Description; Review State; Source URL; Target URL

	Boundaries

	Source / Concept; DO_NOT_INFER; Target / Concept; Reason

	Reading Paths

	Path Name; Step; Entry #; Purpose; URL

Appendix B — Reference GROOVE_OPTIONS Layout

Table B1. Reference hidden sheet layout

Section

	Contents

	Schema Metadata

	GROOVE Schema Version; Vocabulary Version; Last Updated

	Relations

	Name; definition; directionality; example

	Entry Roles

	Allowed Role values and definitions

	Document Status

	Allowed lifecycle values

	Relation Review

	PROPOSED; REVIEWED; VERIFIED; STALE; RETIRED

	Epistemic Status

	ESTABLISHED; DEVELOPING; EXPERIMENTAL; HYPOTHESIS; FANTASY

	Importance

	CORE; HIGH; NORMAL; OPTIONAL

	Custom Extensions

	Deployment-specific values with definitions

Appendix C — Example 000 Master Layout

Table C1. Reference 000 INDEX layout

#

	Bundle

	Purpose

	Folder Link

	00 GROOVE

	Foundation

	Status

	Key Contents

	01

	System Alpha

	Core semantic architecture

	OPEN

	OPEN

	01

	ACTIVE

	Identity, models, relations

	02

	System Beta

	Physical implementation

	OPEN

	OPEN

	01

	ACTIVE

	Landmarks, coordinates, operations

	03

	System Gamma

	Learning and institutional model

	OPEN

	OPEN

	01

	ACTIVE

	Learning, reuse, Academy

Appendix D — AI GROOVE Build Prompt

REFERENCE PROMPT

Read every Entry in this folder before proposing the Bundle map. Populate the Document Registry with Number, Title, Version, Role, Status, Description, and URL where available. Propose only high-value relations using the registered GROOVE relation vocabulary. For each proposed relation, record Source, Relation, Target, scope, a concise reason, and natural-language Source/Target Location descriptions that would help a future reader orient inside the documents. Mark every machine-generated relation PROPOSED. Identify any important DO_NOT_INFER boundaries. Do not promote a relation to REVIEWED or VERIFIED without the required human or authorized review step.

Appendix E — AI GROOVE Navigation Prompt

REFERENCE PROMPT

Before globally searching the corpus, use 000 - GROOVE Master to identify the likely System Understanding Bundle. Open that Bundle’s 00 - GROOVE manifest. Resolve the Entry roles, relevant relations, review states, Boundaries, and Reading Paths. Follow the target Entry Locator and use the recorded semantic location description to orient inside the source. Read the observable source context before answering. Treat GROOVE metadata as routing and orientation, not as a substitute for the source. If the source and GROOVE conflict, report the mismatch and prefer the source.

Appendix F — Quick Build Checklist

Table F1. GROOVE implementation checklist

Check

	Requirement

	□

	Bundle has a clear name and purpose.

	□

	00 - GROOVE.xlsx exists beside the source Entries.

	□

	Visible GROOVE sheet contains a Document Registry.

	□

	Every registered Entry has Number, Title, and working locator.

	□

	High-value relations use controlled dropdown vocabulary.

	□

	Important relation rows explain why the edge exists.

	□

	Source/Target Location descriptions are added where useful.

	□

	Machine-proposed rows are visibly marked PROPOSED.

	□

	GROOVE_OPTIONS carries relation, role, and status vocabularies.

	□

	Workbook records schema/vocabulary version.

	□

	000 Master lists the Bundle and links to its folder and 00 manifest.

	□

	Material source changes trigger re-GROOVE review.

Glossary

Table G1. Glossary

Term

	Meaning

	Bundle

	A System Understanding Bundle: Entries intended to be understood together.

	Entry

	An observable versioned artifact that carries substantive source content.

	Entry Handle

	Compact local number used to refer to an Entry inside a Bundle.

	Entry Locator

	Resolvable address that opens, focuses, or retrieves an Entry.

	GROOVE

	Grounded Relations Over Observable Versioned Entries.

	GROOVE Boundary

	Explicit prohibition against a plausible but invalid inference.

	GROOVE Master

	000 corpus navigation workbook.

	GROOVE Manifest

	00 local Bundle workbook.

	GROOVE_OPTIONS

	Hidden support worksheet containing controlled vocabularies and schema metadata.

	Reading Path

	Optional ordered route through Entries for a bounded intent.

	Re-GROOVE

	Review and update of manifest relations after source or structural change.

	Semantic Handle

	Compact identity, relation, locator, authority, or orientation cue used to reduce retrieval ambiguity.

	Semantic Landing Orientation

	Natural-language description of where to look inside an Entry.