id3-cli 0.9.1

package/templates/CLAUDE.md

@@ -0,0 +1,215 @@
+# IDDD - Information Design-Driven Development
+
+You are working in a project that follows **IDDD (Information Design-Driven Development)**. The information model is the generative center of all development. Every artifact - requirements, API contracts, screen designs, business rules, tests - is derived from and traceable to `specs/entity-catalog.md`.
+
+**Core principle:** Start from "what information exists?" rather than "what features should we build?"
+
+---
+
+## Core Principles
+
+1. **Information model is the single source of truth.** All code, APIs, UI, and tests are derived from entity-catalog.md and data-model.md. If code disagrees with the spec, the spec wins - update the code, not the spec (unless there is a deliberate model change).
+
+2. **Entity-first identification.** Before writing any code, entities must be identified and documented. New features start with "what entities are involved?" not "what endpoints do we need?"
+
+3. **Data model traceability.** Every column, constraint, and relationship in the codebase must trace back to an entry in entity-catalog.md and data-model.md. Untracked schema elements are considered drift.
+
+4. **Output-first design.** Design what users see (dashboards, reports, lists) before designing inputs (forms, APIs). The output image drives the information model.
+
+5. **Business rules are explicit.** Every validation, constraint, and derivation rule is registered in `docs/business-rules.md` with a BR-xxx identifier. Code-only rules are considered debt.
+
+---
+
+## Required Reference Files
+
+Before starting any task, read these files to understand the current state of the information model:
+
+| File | Purpose |
+|------|---------|
+| `specs/entity-catalog.md` | Entity definitions, attributes, relationships, business rule references |
+| `specs/data-model.md` | Mermaid ERD, design decisions, index strategy |
+| `specs/ui-structure.md` | Screen inventory and navigation structure (Phase 2.5) |
+| `specs/ui-design-contract.md` | Visual design contract -- tokens, components, copywriting (Phase 2.5) |
+| `specs/ui-inventory.md` | Current UI structure (brownfield projects) |
+| `docs/business-rules.md` | All business rules (BR-xxx) with enforcement locations |
+| `steering/data-conventions.md` | Naming, typing, PK strategy, and structural conventions |
+| `steering/product.md` | Product vision, scope, and priorities |
+| `docs/domain-glossary.md` | Domain terms and definitions |
+| `docs/info-debt.md` | Known discrepancies and technical debt items |
+| `docs/model-changelog.md` | History of model changes (Keep a Changelog format) |
+
+---
+
+## Agent Teams Rules
+
+This project uses **Agent Teams** for parallel work. Subagents are NOT used. The rules below govern how you operate as a lead agent and how you spawn team members.
+
+### Lead Agent Role
+
+As the lead agent, you do NOT write code or modify files directly. Your responsibilities are:
+
+1. **Task distribution:** Assign clear, scoped tasks to team members.
+2. **Progress tracking:** Monitor each team member's work.
+3. **Quality review:** Review team output against the information model.
+4. **Feedback:** Provide specific, actionable feedback referencing spec entries.
+5. **Final integration:** Verify that all work aligns with the information model.
+
+If implementation is needed, delegate it to a team member. Never do it yourself.
+
+### Spawning Team Members
+
+When spawning a team member, ALWAYS include these 7 files as context:
+
+1. `specs/entity-catalog.md`
+2. `specs/data-model.md`
+3. `specs/ui-structure.md`
+4. `specs/ui-design-contract.md`
+5. `docs/business-rules.md`
+6. `steering/data-conventions.md`
+7. `CLAUDE.md` (this file)
+
+Each team member operates in an **independent context** with its own worktree. Team members communicate via peer-to-peer messaging, not through the lead agent.
+
+### Standard Team Roles
+
+| Role | Responsibility |
+|------|---------------|
+| spec-generator | Transform information model into implementation-ready specs (requirements.md, api-contracts.md) |
+| implementer | Build code from specs, one entity per commit |
+| qa-reviewer | Verify implementation against information model, reject on mismatch |
+
+### Task Generation Rules
+
+1. Read `specs/entity-catalog.md` to extract the entity list.
+2. Create one task per entity (model + migration + API + validation + tests).
+3. Analyze FK dependencies from `specs/data-model.md` to build a dependency graph.
+4. Independent entities (no FK to other project entities) run in parallel.
+5. Dependent entities wait for their parent entities to complete.
+6. Within each dependency wave, assign tasks to team members in parallel.
+
+---
+
+## Hook System
+
+This project uses an automated harness that monitors development:
+
+### Schema Drift Detection (PreToolUse - severity: BLOCK)
+
+When you modify schema-related files (migrations, ORM definitions, model files), the harness checks whether `specs/entity-catalog.md` has been updated accordingly. If not, the change is **blocked**. Always update entity-catalog.md first, then modify the schema.
+
+### Rule Check (PostToolUse - severity: WARN)
+
+When you add validation logic (Zod, Yup, Joi, Pydantic, etc.), the harness checks for a corresponding BR-xxx entry in `docs/business-rules.md`. If missing, you receive a warning. Register the rule before or alongside the validation code.
+
+### Auto-Audit (Stop - severity: INFO)
+
+After every N commits (configured in `.claude/hooks/hook-config.json`), the harness runs an automatic audit comparing the codebase against the information model. Review findings at the start of the next session.
+
+### Hook Bypass
+
+- Set `IDDD_SKIP_HOOKS=1` to skip all hooks temporarily.
+- Bypasses are logged to `.iddd/skip-history.log` and reviewed during audits.
+- Avoid bypassing hooks. If you must, address the underlying issue promptly.
+
+---
+
+## Entropy Management
+
+### Version Headers
+
+`specs/entity-catalog.md` and `specs/data-model.md` contain YAML frontmatter with version tracking:
+
+```yaml
+---
+version: "1.0"
+last_verified: "YYYY-MM-DD"
+phase: "Phase 2 Complete"
+entity_count: N
+rule_count: N
+audit_status: "clean"
+---
+```
+
+**Rules:**
+- Update `last_verified` whenever you audit or verify the model.
+- Increment `version` on each phase completion (Phase 1: 0.1, Phase 2: 1.0, subsequent: 1.1, 1.2, ...).
+- If `last_verified` is more than 7 days ago, run `/id3-info-audit` before proceeding with new work. Stale models lead to drift.
+
+### Change Log
+
+Record all model changes in `docs/model-changelog.md` using Keep a Changelog format. Every entity addition, modification, or removal should have an entry.
+
+---
+
+## Preview System
+
+This project includes a visual preview system for reviewing the information model in a browser.
+
+### Generated Previews
+
+- **ERD Preview:** Mermaid ERD rendered as interactive HTML in `.iddd/preview/`.
+- **UI Mockup:** Wireframe layouts of proposed screens in `.iddd/preview/`.
+- **Audit Dashboard:** Visual audit report with per-entity status cards in `.iddd/preview/`.
+
+### When to Generate Previews
+
+- After completing Phase 0/1 (entity identification): Generate ERD preview.
+- After completing Phase 2 (information design): Generate ERD + UI mockup previews.
+- After completing Phase 2.5 (UI design): Generate mockup index + per-entity mockup previews.
+- After running `/id3-info-audit`: Generate audit dashboard.
+- Manual preview: Use `/id3-preview` to start the server with current specs.
+
+### Preview Files
+
+All preview HTML files are stored in `.iddd/preview/` and persist between sessions. They can be opened directly in a browser without the preview server.
+
+---
+
+## Security Rules
+
+1. **Never commit secrets.** Do not add `.env`, credentials, API keys, or tokens to version control.
+2. **Never skip hooks without logging.** Hook bypasses must be recorded and resolved.
+3. **Never modify spec files during implementation.** If implementation reveals a spec gap, escalate to the lead agent or run an audit - do not silently change the spec.
+4. **Never delete entities from entity-catalog.md without a changelog entry.** Removals must be documented.
+
+---
+
+## New Feature Workflow
+
+When adding a new feature:
+
+1. **Identify entities involved.** Read entity-catalog.md. If new entities are needed, run `/id3-identify-entities` first.
+2. **Check business rules.** Read business-rules.md for relevant BR-xxx rules.
+3. **Check UI structure.** Read ui-structure.md for screen inventory and ui-design-contract.md for design tokens.
+4. **Implement following the spec.** Every line of code should trace to a spec entry.
+5. **Register new rules.** If new validation logic is added, register it as BR-xxx in business-rules.md.
+6. **Update the changelog.** Record what changed in model-changelog.md.
+
+---
+
+## Technology Stack
+
+> _Fill in the project's tech stack below._
+
+- **Language:**
+- **Framework:**
+- **Database:**
+- **ORM:**
+- **Validation:**
+- **Testing:**
+- **Build:**
+
+## Build and Test
+
+> _Fill in the project's build and test commands below._
+
+```bash
+# Build
+# npm run build
+
+# Test
+# npm test
+
+# Lint
+# npm run lint
+```

package/templates/README.md

@@ -0,0 +1,476 @@
+# IDDD -- Information Design-Driven Development
+
+```
+  ___  ____  ____  ____
+ |_ _||  _ \|  _ \|  _ \
+  | | | | | | | | | | | |
+  | | | |_| | |_| | |_| |
+ |___||____/|____/|____/
+
+ Information Design-Driven Development
+ "What information exists?" before "What features should we build?"
+```
+
+Most software projects start by asking *"What features should we build?"* and jump
+straight into implementation. IDDD inverts this: it starts from **"What information
+exists in this domain?"** By building a rigorous information model first -- entity
+catalog, data model, business rules, and domain glossary -- IDDD ensures that 80% of
+application behavior is already defined before any technology choice is made. The
+information model then becomes the generative center from which requirements, API
+contracts, screen designs, and validation rules are systematically derived. This
+package installs IDDD as a set of AI agent skills, harness hooks, and document
+templates so that your coding agent enforces information-first discipline throughout
+the entire development lifecycle.
+
+---
+
+## Supported Platforms
+
+| Platform    | Agent System         | Multi-Agent Strategy             |
+|-------------|----------------------|----------------------------------|
+| Claude Code | Claude Agent Teams   | Peer messaging, independent worktrees |
+| OpenAI Codex| Codex Agents SDK     | Handoff pattern via MCP Server   |
+
+---
+
+## Prerequisites
+
+| Platform    | Requirement                                          |
+|-------------|------------------------------------------------------|
+| Claude Code | **Claude Max** membership + Agent Teams enabled      |
+| OpenAI Codex| **ChatGPT Plus** or higher (Pro/Business/Enterprise) |
+
+You also need **Node.js 18+** and **npm** (or a compatible package manager) installed
+on your machine.
+
+---
+
+## Installation
+
+```bash
+npx id3@latest
+```
+
+The `init` command will:
+1. Copy all IDDD templates (specs, docs, steering, skills, hooks) into your project.
+2. Create platform-specific symlinks (`.claude/skills/` or `.agents/skills/`).
+3. Register harness hooks in your platform's configuration file.
+4. Initialize the `.iddd/` state directory (commit counter, preview output).
+
+---
+
+## Directory Structure
+
+After installation, your project gains the following directories:
+
+```
+your-project/
+│
+│   ===== Shared (all platforms) =====
+│
+├── skills/                          Skill originals (single source of truth)
+│   ├── id3-identify-entities/       Phase 0/1: Entity identification
+│   │   ├── SKILL.md
+│   │   └── references/
+│   │       ├── phase0-brownfield.md   Reverse-extract from existing code
+│   │       └── phase1-greenfield.md   Structured interview for new projects
+│   ├── id3-design-information/      Phase 2: Information structuring
+│   │   ├── SKILL.md
+│   │   └── references/
+│   │       ├── phase2-procedure.md    Refinement procedure
+│   │       └── ui-proposal-guide.md   UI derivation from info model
+│   ├── id3-design-ui/              Phase 2.5: UI design and implementation
+│   │   ├── SKILL.md
+│   │   └── references/
+│   │       ├── step1-structure-derivation.md
+│   │       ├── step2-visual-contract.md
+│   │       ├── step3-gate-and-mockup.md
+│   │       └── step4-implementation.md
+│   ├── id3-spawn-team/              Dispatch multi-agent implementation
+│   ├── id3-info-audit/              Entropy audit (drift detection)
+│   └── id3-preview/                 Visual preview of information model
+│
+├── specs/                           Information model artifacts
+│   ├── entity-catalog.md              Entity inventory + summary table
+│   ├── data-model.md                  Mermaid ERD + design decisions
+│   ├── ui-inventory.md                Screen inventory + mapping matrix
+│   ├── ui-structure.md                Screen inventory + navigation structure (Phase 2.5)
+│   └── ui-design-contract.md          Visual design contract -- tokens, components (Phase 2.5)
+│
+├── docs/                            Supporting documentation
+│   ├── business-rules.md              BR-xxx indexed business rules
+│   ├── domain-glossary.md             Term / English / definition / notes
+│   ├── info-debt.md                   Inconsistency tracker
+│   └── model-changelog.md            Keep-a-Changelog format
+│
+├── steering/                        Project-level conventions
+│   ├── product.md                     Product vision & scope (user-authored)
+│   └── data-conventions.md            PK strategy, naming, timestamps, etc.
+│
+├── hooks/                           Harness hook scripts (built JS bundles)
+│   ├── iddd-schema-drift.js           Schema drift detection
+│   ├── iddd-rule-check.js             Business rule tracking
+│   ├── iddd-auto-audit.js             Automatic entropy audit
+│   ├── pre-commit                     Git hook (schema-drift + rule-check)
+│   └── post-commit                    Git hook (auto-audit)
+│
+├── .iddd/                           IDDD internal state
+│   ├── commit-count                   Auto-audit interval counter
+│   └── preview/                       Generated preview HTML
+│
+│   ===== Platform: Claude Code =====
+│
+├── CLAUDE.md                        Lead agent context document
+├── .claude/
+│   ├── settings.local.json            Hook registration (injected by init)
+│   ├── skills/ -> skills/             Symlinks to skills/ originals
+│   └── hooks/
+│       └── hook-config.json           IDDD hook settings (enable/disable, patterns)
+│
+│   ===== Platform: OpenAI Codex =====
+│
+├── AGENTS.md                        Cross-platform agent instructions (<32 KiB)
+├── .agents/
+│   └── skills/ -> skills/             Symlinks to skills/ originals
+└── .codex/
+    └── hooks.json                     Codex hook configuration
+```
+
+---
+
+## Workflow
+
+```
+ ┌────────────────────────────────────────────────────────────────────┐
+ │                      IDDD WORKFLOW OVERVIEW                       │
+ └────────────────────────────────────────────────────────────────────┘
+
+ [User] <---dialog---> [Lead Agent]
+                          |
+                          |--- Existing code?
+                          |      |
+                          |      v
+                          |    Phase 0 (Reverse-Extract)
+                          |      |  Scan ORM/schema files
+                          |      |  Extract entities & relationships
+                          |      v
+                          |    Verification Interview --------+
+                          |                                   |
+                          |--- No existing code?              |
+                          |      |                            |
+                          |      v                            |
+                          |    Phase 1 (Structured Interview) |
+                          |      |  "What information does    |
+                          |      |   your domain manage?"     |
+                          |      v                            |
+                          |    Entity Catalog produced -------+
+                          |                                   |
+                          |                                   v
+                          |--- Phase 2: Information Design <--+
+                          |      |
+                          |      |  Conceptual -> Logical model
+                          |      |  Derive business rules
+                          |      |  Register hooks + version headers
+                          |      v
+                          |
+                          +--- Phase 2.5: UI Design
+                          |      |
+                          |      |  Entity -> Screen derivation
+                          |      |  Visual design contract
+                          |      |  7-Pillar gate + mockup preview
+                          |      |  Agent Teams implementation
+                          |      v
+                          |
+                          +--- /id3-spawn-team
+                                 |
+                    +------------+------------------+
+                    |                               |
+              [Claude Code]                    [Codex]
+              Agent Teams                      Agents SDK
+                    |                               |
+              +-----+-------+                       |
+              |     |       |                       |
+              v     v       v                       v
+           [spec] [impl] [qa]                  [handoff]
+              |     |       |
+              +-- messaging-+
+
+
+ ┌────────────────────────────────────────────────────────────────────┐
+ │                        HARNESS HOOKS                              │
+ ├────────────────────────────────────────────────────────────────────┤
+ │                                                                    │
+ │  PreToolUse / pre-commit:                                         │
+ │    +-- Schema drift BLOCK                                         │
+ │    |   "Entity added to code but missing from entity-catalog.md"  │
+ │    +-- Rule tracking WARN                                         │
+ │        "Validation logic changed; check business-rules.md"        │
+ │                                                                    │
+ │  Stop / post-commit:                                              │
+ │    +-- Auto info-audit (every N commits)                          │
+ │        Compare specs/ against actual code for entropy drift       │
+ │                                                                    │
+ └────────────────────────────────────────────────────────────────────┘
+```
+
+---
+
+## Quick Start
+
+### Step 1: Initialize IDDD in your project
+
+```bash
+cd your-project
+npx id3@latest
+```
+
+This scaffolds all IDDD directories, registers hooks, and links skills to your
+platform.
+
+### Step 2: Identify entities
+
+Open your AI coding agent and say:
+
+```
+identify entities
+```
+
+- **Brownfield** (existing code detected): The agent runs Phase 0 -- it scans your
+  ORM schemas, migration files, and model definitions, then extracts entities and
+  relationships into `specs/entity-catalog.md` and `specs/data-model.md`. You will
+  be asked verification questions to confirm or correct the extraction.
+- **Greenfield** (no existing code): The agent runs Phase 1 -- a structured
+  interview asking "What information does your domain manage?" to collaboratively
+  build the initial entity catalog.
+
+### Step 3: Design information model
+
+Once entities are identified, say:
+
+```
+design information
+```
+
+The agent runs Phase 2: it refines your conceptual model into a logical model,
+derives business rules (`docs/business-rules.md`), and sets up version headers
+and hook configurations.
+
+### Step 3.5: Design UI (Phase 2.5)
+
+After Phase 2 completes, say:
+
+```
+design ui
+```
+
+The agent runs Phase 2.5: it derives screen structure from the entity catalog
+(`specs/ui-structure.md`), establishes a visual design contract with design tokens
+(`specs/ui-design-contract.md`), runs a 7-pillar quality gate with interactive
+mockup previews, and spawns Agent Teams for parallel screen implementation with
+post-audit. After Phase 2.5 completes, use `/id3-spawn-team` to dispatch
+implementation agents.
+
+---
+
+## Customization Guide
+
+IDDD is designed to be adapted to your project's conventions. Here is what to
+customize and where:
+
+| What to customize              | File to edit                      |
+|--------------------------------|-----------------------------------|
+| Product vision & scope         | `steering/product.md`             |
+| Naming conventions, PK strategy, timestamps, soft-delete policy, ENUM vs reference tables | `steering/data-conventions.md` |
+| Business rules                 | `docs/business-rules.md`          |
+| Domain glossary                | `docs/domain-glossary.md`         |
+| Entity definitions             | `specs/entity-catalog.md`         |
+| Data model (ERD)               | `specs/data-model.md`             |
+| UI screen inventory            | `specs/ui-inventory.md`           |
+| UI structure                   | `specs/ui-structure.md`           |
+| UI design contract             | `specs/ui-design-contract.md`     |
+| Hook behavior (enable/disable) | `.claude/hooks/hook-config.json`  |
+| Monitored file patterns        | `.claude/hooks/hook-config.json`  |
+| Auto-audit interval            | `.claude/hooks/hook-config.json`  |
+| Codex hook configuration       | `.codex/hooks.json`               |
+
+**Tip:** All `specs/` and `docs/` files use YAML frontmatter with version headers.
+The IDDD harness tracks these versions to detect entropy drift. Always update the
+version header when you modify a spec file.
+
+---
+
+## Harness Configuration Guide
+
+The IDDD harness enforces information-first discipline through automated hooks. All
+hook settings live in `.claude/hooks/hook-config.json` (Claude Code) or
+`.codex/hooks.json` (Codex).
+
+### Hook Overview
+
+```
+ Hook Config (.claude/hooks/hook-config.json)
+ +--------------------------------------------+
+ |  enabled: true | false                     |   Master switch
+ +--------------------------------------------+
+ |                                            |
+ |  pre-commit:                               |
+ |  +-- schema-drift                          |
+ |  |   enabled: true                         |
+ |  |   severity: "block" | "warn"            |   Block or warn on drift
+ |  |   monitored_patterns:                   |
+ |  |     - prisma/schema.prisma              |
+ |  |     - drizzle/**/*.ts                   |
+ |  |     - **/migrations/*.sql               |   Add your ORM patterns
+ |  |     - **/models.py                      |
+ |  |     - **/entities/*.ts                  |
+ |  |     - **/entities/*.java                |
+ |  |                                         |
+ |  +-- rule-check                            |
+ |      enabled: true                         |
+ |      severity: "warn"                      |
+ |      validation_patterns:                  |
+ |        - *.schema.ts                       |
+ |        - *.validator.*                     |   Add your validator patterns
+ |        - **/validators/**                  |
+ |                                            |
+ |  post-commit:                              |
+ |  +-- auto-audit                            |
+ |      enabled: true                         |
+ |      interval_commits: 10                  |   Run audit every N commits
+ |                                            |
+ +--------------------------------------------+
+```
+
+### Enabling / Disabling Hooks
+
+To disable all IDDD hooks at once, set the top-level `enabled` flag to `false`:
+
+```json
+{
+  "enabled": false,
+  ...
+}
+```
+
+To disable a specific hook while keeping others active:
+
+```json
+{
+  "enabled": true,
+  "hooks": {
+    "pre-commit": {
+      "schema-drift": {
+        "enabled": false
+      }
+    }
+  }
+}
+```
+
+### Adjusting Auto-Audit Interval
+
+The auto-audit runs every N commits. To change the interval:
+
+```json
+{
+  "hooks": {
+    "post-commit": {
+      "auto-audit": {
+        "enabled": true,
+        "interval_commits": 5
+      }
+    }
+  }
+}
+```
+
+Set `interval_commits` to a lower number for stricter entropy control, or higher for
+less frequent audits. The commit counter is stored in `.iddd/commit-count`.
+
+### Adding Schema Monitoring Patterns
+
+If your project uses an ORM or schema tool not covered by the defaults, add its file
+patterns to `monitored_patterns`:
+
+```json
+{
+  "hooks": {
+    "pre-commit": {
+      "schema-drift": {
+        "monitored_patterns": [
+          "prisma/schema.prisma",
+          "drizzle/**/*.ts",
+          "**/migrations/*.sql",
+          "**/models.py",
+          "**/entities/*.ts",
+          "**/entities/*.java",
+          "src/database/**/*.entity.ts",
+          "sequelize/models/**/*.js"
+        ]
+      }
+    }
+  }
+}
+```
+
+### Schema Drift Severity
+
+- `"block"` -- The hook will **reject** the commit / tool use if schema drift is
+  detected. The agent must update `specs/entity-catalog.md` and `specs/data-model.md`
+  before proceeding.
+- `"warn"` -- The hook emits a warning but allows the operation to continue.
+
+---
+
+## Codex Configuration
+
+For OpenAI Codex, hooks are configured in `.codex/hooks.json`. This file is
+automatically generated by `npx id3@latest`.
+
+**Important:** If your project uses a `config.toml` for Codex agent settings, ensure
+that hooks are enabled:
+
+```toml
+# config.toml
+codex_hooks = true
+```
+
+Without this flag, Codex will not execute the IDDD hook scripts during the agent
+loop. The hooks.json file defines three event bindings:
+
+| Event         | Hook Script               | Purpose                      |
+|---------------|---------------------------|------------------------------|
+| PreToolUse    | `hooks/iddd-schema-drift.js`| Schema drift detection      |
+| PostToolUse   | `hooks/iddd-rule-check.js`  | Business rule tracking      |
+| SessionStart  | `hooks/iddd-auto-audit.js`  | Entropy audit on session start |
+
+To disable a specific Codex hook, remove or comment out its entry in `.codex/hooks.json`.
+
+---
+
+## Intellectual Lineage
+
+IDDD synthesizes ideas from several intellectual traditions:
+
+- **Peter Chen's ER Model (1976)** -- "The real world consists of entities and relationships."
+- **Len Silverston's Universal Data Models** -- Reusable information patterns (Party, Product, Order, Hierarchy).
+- **Eric Evans' DDD (2003)** -- Bounded Context, Ubiquitous Language, Aggregate.
+- **Sophia Prater's OOUX** -- "Design objects before interactions" (ORCA: Objects, Relationships, CTAs, Attributes).
+- **Jamie Lord's "Data First, Code Second" (2024)** -- "Fold knowledge into data" (Unix Rule of Representation).
+- **Mitchell Hashimoto's Harness Engineering (2026)** -- Agent = Model + Harness. Context engineering + architecture constraints + entropy management.
+
+**Core insight:** *When the logical model is complete, 80% of application behavior is
+already defined -- before any technology choice is made. And that information model
+itself is the best harness for AI agents.*
+
+---
+
+## License
+
+MIT
+
+---
+
+```
+  "What information exists?" -- always the first question.
+```