holosphere 2.0.0-alpha0 → 2.0.0-alpha2

package/docs/tasks.md

@@ -0,0 +1,947 @@
+# Tasks: HoloSphere - Holonic Geospatial Communication Infrastructure
+
+**Input**: Design documents from `/Users/roberto/Projects/Liminal/holosphere2/specs/001-holosphere-holonic-geospatial/`
+**Prerequisites**: plan.md, research.md, data-model.md, contracts/, quickstart.md (all present)
+**Branch**: `001-holosphere-holonic-geospatial`
+
+## Execution Flow (main)
+```
+1. Load plan.md from feature directory ✓
+   → Tech stack: JavaScript ES2020+, GunDB, h3-js, @noble/curves, Ajv
+   → Structure: Single library project (src/, tests/)
+2. Load design documents ✓
+   → data-model.md: 9 entities (Holon, Lens, Data Object, etc.)
+   → contracts/api-interface.md: 10 API categories, ~30 methods
+   → quickstart.md: 9 integration test scenarios
+   → research.md: Technical decisions and tooling
+3. Generate tasks by category:
+   → Setup: npm project, Vite, Vitest, ESLint
+   → Tests: Contract tests (30), Integration tests (9), Unit tests (8 modules)
+   → Core: 8 modules (core, spatial, storage, schema, federation, content, crypto, subscriptions)
+   → Integration: Public API wiring, build configuration
+   → Polish: Bundle optimization, TypeScript definitions, documentation
+4. Apply task rules:
+   → Test files in parallel [P]
+   → Module implementations in parallel where no dependencies [P]
+   → TDD order enforced (tests before implementation)
+5. Total tasks: 42 numbered tasks (T001-T042)
+6. Dependencies mapped (see Dependencies section)
+7. Parallel execution examples provided
+8. Validation: All contracts tested, all entities modeled, TDD order preserved
+```
+
+## Format: `[ID] [P?] Description`
+- **[P]**: Can run in parallel (different files, no dependencies)
+- Include exact file paths in descriptions
+- Repository root: `/Users/roberto/Projects/Liminal/holosphere2/`
+
+---
+
+## Phase 3.1: Setup & Infrastructure
+
+### T001: Initialize npm project with dependencies
+**File**: `package.json`
+**Description**: Create package.json with:
+- Package name: `holosphere`
+- Type: `module` (ESM)
+- Dependencies: `gun` (GunDB), `h3-js`, `@noble/curves`, `ajv`
+- Dev dependencies: `vite`, `vitest`, `eslint`, `prettier`
+- Scripts: `dev`, `build`, `test`, `test:coverage`, `lint`, `format`
+
+**Acceptance**: `npm install` completes without errors
+
+---
+
+### T002: Configure Vitest for unit and integration testing
+**File**: `vitest.config.js`
+**Description**: Create Vitest configuration:
+- Test file patterns: `**/*.test.js`
+- Coverage provider: `v8`
+- Coverage threshold: 80% line coverage
+- Test environment: `node` (default)
+- Include directories: `tests/unit/`, `tests/integration/`, `tests/contract/`
+
+**Acceptance**: `npm test` runs (no tests yet, but config loads)
+
+---
+
+### T003: [P] Configure Vite for multi-format build
+**File**: `vite.config.js`
+**Description**: Create Vite build configuration:
+- Entry point: `src/index.js`
+- Output formats: ESM (`dist/esm/`), CommonJS (`dist/cjs/`), UMD (`dist/cdn/`)
+- Library name: `HoloSphere`
+- External dependencies: none (bundle all for CDN)
+- Minification: terser for production
+- Sourcemaps enabled
+
+**Acceptance**: `npm run build` creates all three output formats
+
+---
+
+### T004: [P] Configure ESLint and Prettier
+**Files**: `.eslintrc.json`, `.prettierrc.json`
+**Description**:
+- ESLint: ES2020 environment, recommended rules, async-await support
+- Prettier: 2-space indent, single quotes, semicolons, trailing commas
+- ESLint plugin prettier integration
+
+**Acceptance**: `npm run lint` and `npm run format` execute without errors
+
+---
+
+### T005: Create source directory structure
+**Directories**: Create all module directories per plan.md:
+```
+src/
+├── core/
+├── spatial/
+├── storage/
+├── schema/
+├── federation/
+├── hierarchical/
+├── content/
+├── crypto/
+├── subscriptions/
+└── utils/
+```
+
+**Acceptance**: Directory tree matches plan.md structure
+
+---
+
+### T006: Create test directory structure
+**Directories**: Create test directories:
+```
+tests/
+├── unit/
+├── integration/
+└── contract/
+```
+
+**Acceptance**: All test directories exist
+
+---
+
+## Phase 3.2: Tests First (TDD) ⚠️ MUST COMPLETE BEFORE 3.3
+
+**CRITICAL: These tests MUST be written and MUST FAIL before ANY implementation**
+
+### Contract Tests (API Interface) - All [P]
+
+### T007: [P] Contract test: Core initialization
+**File**: `tests/contract/core.test.js`
+**Description**: Test `new HoloSphere(config)` constructor:
+- Default config creates instance
+- Custom appName, peers, radisk config works
+- Invalid config throws TypeError
+- Instance has all expected methods
+
+**Acceptance**: Test written, fails (HoloSphere not implemented)
+
+---
+
+### T008: [P] Contract test: Spatial operations
+**File**: `tests/contract/spatial.test.js`
+**Description**: Test spatial API methods:
+- `toHolon(lat, lng, resolution)` → H3 string
+- `getParents(holonId, maxResolution)` → parent array
+- `getChildren(holonId)` → 7 children
+- `isValidH3(holonId)` → boolean
+- Error cases: invalid coords, out of range resolution
+
+**Acceptance**: Test written, fails (spatial methods not implemented)
+
+---
+
+### T009: [P] Contract test: Data operations (write/read/update/delete)
+**File**: `tests/contract/data.test.js`
+**Description**: Test CRUD API methods:
+- `write(holonId, lensName, data, options)` → boolean
+- `read(holonId, lensName, dataId?)` → object | array | null
+- `update(holonId, lensName, dataId, updates, options)` → boolean
+- `delete(holonId, lensName, dataId, options)` → boolean
+- Validate signatures, parameter types, return values
+
+**Acceptance**: Test written, fails (data methods not implemented)
+
+---
+
+### T010: [P] Contract test: Schema operations
+**File**: `tests/contract/schema.test.js`
+**Description**: Test schema API methods:
+- `setSchema(lensName, schemaUri, strict?)` → void
+- `getSchema(lensName)` → object | null
+- `clearSchema(lensName)` → void
+- Validate JSON Schema 2019 format enforcement
+
+**Acceptance**: Test written, fails (schema methods not implemented)
+
+---
+
+### T011: [P] Contract test: Federation operations
+**File**: `tests/contract/federation.test.js`
+**Description**: Test federation API methods:
+- `federate(sourceHolon, targetHolon, lensName, options)` → boolean
+- `getFederatedData(holonId, lensName, options)` → array
+- `unfederate(sourceHolon, targetHolon, lensName)` → boolean
+- Options: direction, mode, filter validation
+
+**Acceptance**: Test written, fails (federation methods not implemented)
+
+---
+
+### T012: [P] Contract test: Hierarchical operations
+**File**: `tests/contract/hierarchical.test.js`
+**Description**: Test upcast API method:
+- `upcast(holonId, lensName, dataId, options)` → boolean
+- Options: maxLevel, operation validation
+- Error: noospheric holons (no hierarchy)
+
+**Acceptance**: Test written, fails (upcast not implemented)
+
+---
+
+### T013: [P] Contract test: Subscription operations
+**File**: `tests/contract/subscriptions.test.js`
+**Description**: Test subscription API:
+- `subscribe(holonId, lensName, callback, options)` → { unsubscribe }
+- Callback invoked on data changes
+- Unsubscribe stops callbacks
+- Options: includeFederated, throttle, filter
+
+**Acceptance**: Test written, fails (subscribe not implemented)
+
+---
+
+### T014: [P] Contract test: Cryptographic operations
+**File**: `tests/contract/crypto.test.js`
+**Description**: Test crypto API methods:
+- `sign(content, privateKey)` → signature string
+- `verify(content, signature, publicKey)` → boolean
+- `issueCapability(permissions, scope, recipient, options)` → token
+- `verifyCapability(token, requiredPermission, scope)` → boolean
+- Lazy loading verification (crypto module not loaded until first use)
+
+**Acceptance**: Test written, fails (crypto methods not implemented)
+
+---
+
+### T015: [P] Contract test: Social protocol operations
+**File**: `tests/contract/social.test.js`
+**Description**: Test social protocol API:
+- `publishNostr(event, holonId, lensName?)` → boolean
+- `publishActivityPub(object, holonId, lensName?)` → boolean
+- `querySocial(holonId, options)` → array
+- Nostr NIP-01 and ActivityPub format validation
+
+**Acceptance**: Test written, fails (social methods not implemented)
+
+---
+
+### T016: [P] Contract test: Utility operations
+**File**: `tests/contract/utils.test.js`
+**Description**: Test utility API:
+- `metrics()` → object (writes, reads, subscriptions counts)
+- Error types: ValidationError, AuthorizationError, HolosphereError
+- Error object structure and properties
+
+**Acceptance**: Test written, fails (utils not implemented)
+
+---
+
+### Integration Tests (Quickstart Scenarios) - All [P]
+
+### T017: [P] Integration test: Scenario 1 - Geographic data storage and retrieval
+**File**: `tests/integration/scenario-01-geographic-storage.test.js`
+**Description**: Implement quickstart scenario 1:
+- Convert lat/lng to H3 holon
+- Write temperature data to lens
+- Read data by location + category + ID
+- Query all data in category
+
+**Acceptance**: Test written, fails (full workflow not implemented)
+
+---
+
+### T018: [P] Integration test: Scenario 2 - Hierarchical federation
+**File**: `tests/integration/scenario-02-federation.test.js`
+**Description**: Implement quickstart scenario 2:
+- Create local data
+- Federate local → regional holon
+- Query regional (includes local via hologram)
+- Update local, verify regional sees change (single source of truth)
+
+**Acceptance**: Test written, fails (federation workflow not implemented)
+
+---
+
+### T019: [P] Integration test: Scenario 3 - Real-time subscriptions
+**File**: `tests/integration/scenario-03-subscriptions.test.js`
+**Description**: Implement quickstart scenario 3:
+- Subscribe to holon/lens changes
+- Write data, verify callback invoked
+- Update data, verify callback invoked again
+- Unsubscribe, verify no more callbacks
+
+**Acceptance**: Test written, fails (subscription workflow not implemented)
+
+---
+
+### T020: [P] Integration test: Scenario 4 - Schema validation
+**File**: `tests/integration/scenario-04-validation.test.js`
+**Description**: Implement quickstart scenario 4:
+- Define JSON Schema for lens
+- Permissive mode: invalid data succeeds with warning
+- Strict mode: invalid data throws ValidationError
+- Valid data succeeds in both modes
+
+**Acceptance**: Test written, fails (validation workflow not implemented)
+
+---
+
+### T021: [P] Integration test: Scenario 5 - Multi-scale hierarchical queries
+**File**: `tests/integration/scenario-05-hierarchy.test.js`
+**Description**: Implement quickstart scenario 5:
+- Create data at high resolution (local)
+- Upcast to parent hierarchy
+- Query at different scales (neighborhood, city, region)
+- Verify data propagated to all parent levels
+
+**Acceptance**: Test written, fails (hierarchy workflow not implemented)
+
+---
+
+### T022: [P] Integration test: Scenario 6 - Cross-protocol social content
+**File**: `tests/integration/scenario-06-social.test.js`
+**Description**: Implement quickstart scenario 6:
+- Publish Nostr event to geographic holon
+- Publish ActivityPub object to noospheric holon
+- Query all social (unified interface)
+- Filter by protocol
+- Verify cryptographic signatures
+
+**Acceptance**: Test written, fails (social workflow not implemented)
+
+---
+
+### T023: [P] Integration test: Scenario 7 - Offline persistence
+**File**: `tests/integration/scenario-07-persistence.test.js`
+**Description**: Implement quickstart scenario 7:
+- Initialize with radisk
+- Write data
+- Simulate restart (new instance)
+- Read previously written data (recovered from disk)
+- Offline write, verify immediately available
+
+**Acceptance**: Test written, fails (persistence workflow not implemented)
+
+---
+
+### T024: [P] Integration test: Scenario 8 - Authorization with capability tokens
+**File**: `tests/integration/scenario-08-authorization.test.js`
+**Description**: Implement quickstart scenario 8:
+- User A creates data
+- User B attempts unauthorized delete → AuthorizationError
+- User A issues capability token to User B
+- User B deletes with valid token → success
+- Verify data deleted
+
+**Acceptance**: Test written, fails (authorization workflow not implemented)
+
+---
+
+### T025: [P] Integration test: Scenario 9 - Cross-dimensional federation
+**File**: `tests/integration/scenario-09-cross-dimensional.test.js`
+**Description**: Implement quickstart scenario 9:
+- Create data in geographic holon
+- Create data in noospheric holon (URI)
+- Federate geographic ↔ noospheric (bidirectional)
+- Query geographic → includes noospheric data
+- Query noospheric → includes geographic data
+
+**Acceptance**: Test written, fails (cross-dimensional workflow not implemented)
+
+---
+
+## Phase 3.3: Core Implementation (ONLY after tests are failing)
+
+**Prerequisites**: All tests (T007-T025) written and failing
+
+### Unit Tests (Module-specific) - All [P]
+
+### T026: [P] Unit test for core module
+**File**: `tests/unit/core.test.js`
+**Description**: Unit tests for `src/core/`:
+- HoloSphere class initialization
+- Config validation and defaults
+- GunDB instance creation
+- Radisk adapter integration
+- Log level configuration
+
+**Acceptance**: Test written, fails (core module not implemented)
+
+---
+
+### T027: [P] Unit test for spatial module
+**File**: `tests/unit/spatial.test.js`
+**Description**: Unit tests for `src/spatial/`:
+- H3 validation (starts with '8', ≥15 chars)
+- Coordinate to H3 conversion
+- Parent/child hierarchy navigation
+- Resolution extraction
+- Edge cases (poles, dateline)
+
+**Acceptance**: Test written, fails (spatial module not implemented)
+
+---
+
+### T028: [P] Unit test for storage module
+**File**: `tests/unit/storage.test.js`
+**Description**: Unit tests for `src/storage/`:
+- Path construction (`appname/holon/lens/key`)
+- Gun graph operations (get, put, once)
+- Radisk persistence
+- Path encoding (special characters)
+- Error handling
+
+**Acceptance**: Test written, fails (storage module not implemented)
+
+---
+
+### T029: [P] Unit test for schema module
+**File**: `tests/unit/schema.test.js`
+**Description**: Unit tests for `src/schema/`:
+- JSON Schema 2019 validation
+- Ajv validator compilation
+- Schema caching (1-hour TTL)
+- Cache expiration and recompilation
+- Strict vs permissive mode
+
+**Acceptance**: Test written, fails (schema module not implemented)
+
+---
+
+### T030: [P] Unit test for federation module
+**File**: `tests/unit/federation.test.js`
+**Description**: Unit tests for `src/federation/`:
+- Hologram creation (reference structure)
+- Hologram resolution (dereference)
+- Circular reference detection
+- Federation config validation
+- Inbound/outbound/bidirectional modes
+
+**Acceptance**: Test written, fails (federation module not implemented)
+
+---
+
+### T031: [P] Unit test for content module
+**File**: `tests/unit/content.test.js`
+**Description**: Unit tests for `src/content/`:
+- Nostr event format validation (NIP-01)
+- ActivityPub object format validation
+- Protocol adapter interface
+- Stigmergic access level filtering
+- Content transformation (to/from HoloSphere format)
+
+**Acceptance**: Test written, fails (content module not implemented)
+
+---
+
+### T032: [P] Unit test for crypto module
+**File**: `tests/unit/crypto.test.js`
+**Description**: Unit tests for `src/crypto/`:
+- secp256k1 signing and verification
+- Capability token generation
+- Token expiration validation
+- Nonce uniqueness (replay protection)
+- Lazy initialization (module not loaded until first use)
+
+**Acceptance**: Test written, fails (crypto module not implemented)
+
+---
+
+### T033: [P] Unit test for subscriptions module
+**File**: `tests/unit/subscriptions.test.js`
+**Description**: Unit tests for `src/subscriptions/`:
+- Gun `.on()` listener attachment
+- Callback invocation on data changes
+- Throttling mechanism
+- Filter predicate application
+- Unsubscribe cleanup
+
+**Acceptance**: Test written, fails (subscriptions module not implemented)
+
+---
+
+### T033.5: [P] Unit test for hierarchical module
+**File**: `tests/unit/hierarchical.test.js`
+**Description**: Unit tests for `src/hierarchical/`:
+- Upcast operation with summarize mode
+- Upcast operation with aggregate mode
+- Upcast operation with concatenate mode
+- MaxLevel limit enforcement (default: 3 levels)
+- Parent hierarchy traversal
+- Error: noospheric holons (no hierarchy support)
+
+**Acceptance**: Test written, fails (hierarchical module not implemented)
+
+---
+
+### Module Implementations
+
+### T034: [P] Implement core module
+**File**: `src/core/holosphere.js`
+**Description**: Implement HoloSphere class:
+- Constructor with config validation
+- Initialize GunDB with radisk adapter
+- Set up logging (structured JSON format)
+- Store app configuration
+- Export class
+
+**Dependencies**: None
+**Acceptance**: Unit tests (T026) pass
+
+---
+
+### T035: [P] Implement spatial module
+**File**: `src/spatial/h3-operations.js`
+**Description**: Implement H3 spatial operations:
+- `toHolon(lat, lng, resolution)` using h3-js `geoToH3()`
+- `getParents(holonId, maxResolution)` using `h3ToParent()` iteratively
+- `getChildren(holonId)` using `h3ToChildren()`
+- `isValidH3(holonId)` using `h3IsValid()` + format check
+- `getResolution(holonId)` using `h3GetResolution()`
+- Input validation and error handling
+
+**Dependencies**: T034 (core)
+**Acceptance**: Unit tests (T027) and contract tests (T008) pass
+
+---
+
+### T036: Implement storage module
+**File**: `src/storage/gun-wrapper.js`
+**Description**: Implement GunDB storage wrapper:
+- Path construction (`buildPath(appname, holon, lens, key)`)
+- `write(path, data)` → Gun `.put()` with radisk persistence
+- `read(path)` → Gun `.once()` with Promise wrapper
+- `delete(path)` → Gun `.put(null)` for tombstone
+- `subscribe(path, callback)` → Gun `.on()` with cleanup
+- Path encoding for special characters
+
+**Dependencies**: T034 (core)
+**Acceptance**: Unit tests (T028) pass
+
+---
+
+### T036.5: Implement global data operations
+**File**: `src/storage/global-tables.js`
+**Description**: Extend storage for non-location-specific data (FR-044, FR-045):
+- `writeGlobal(table, data)` → Nostr write to `appname/{table}/{data.id}` (id extracted from data)
+- `readGlobal(table, key?)` → Nostr read from global path
+- `updateGlobal(table, key, updates)` → merge updates
+- `deleteGlobal(table, key)` → tombstone
+- No holon parameter required
+- Consistent CRUD operations matching holon-based data API
+
+**Dependencies**: T036 (storage module)
+**Acceptance**: Extended unit tests (T028) pass with global operations
+
+---
+
+### T037: Implement schema module
+**File**: `src/schema/validator.js`
+**Description**: Implement JSON Schema validation:
+- `compileSchema(schemaUri)` → Ajv validator with caching
+- `validate(data, lensName, strict)` → boolean | ValidationError
+- Schema cache with TTL (1 hour default)
+- Cache invalidation and recompilation
+- Logging for validation failures (permissive mode)
+
+**Dependencies**: T036 (storage for schema retrieval)
+**Acceptance**: Unit tests (T029) and contract tests (T010) pass
+
+---
+
+### T038: Implement federation module
+**File**: `src/federation/hologram.js`
+**Description**: Implement federation and holograms:
+- `createHologram(sourceHolon, targetHolon, lensName, dataId)` → hologram object
+- `resolveHologram(hologram, visitedSet)` → actual data
+- Circular reference detection (max depth: 10)
+- `setupFederation(source, target, lens, options)` → config
+- `propagateData(data, federation)` → create holograms in target
+
+**Dependencies**: T036 (storage), T035 (spatial for hierarchy)
+**Acceptance**: Unit tests (T030) and contract tests (T011) pass
+
+---
+
+### T039: [P] Implement crypto module (lazy loading)
+**File**: `src/crypto/secp256k1.js`
+**Description**: Implement cryptographic operations:
+- Dynamic import of `@noble/curves/secp256k1`
+- `sign(content, privateKey)` → signature
+- `verify(content, signature, publicKey)` → boolean
+- `issueCapability(permissions, scope, recipient, options)` → token
+- `verifyCapability(token, requiredPermission, scope)` → boolean
+- Nonce generation and replay protection
+
+**Dependencies**: None (lazy loaded)
+**Acceptance**: Unit tests (T032) and contract tests (T014) pass
+
+---
+
+### T040: Implement content module
+**File**: `src/content/social-protocols.js`
+**Description**: Implement social protocol adapters:
+- Nostr adapter: NIP-01 event validation, signing, verification
+- ActivityPub adapter: JSON-LD validation, HTTP signatures
+- `publishNostr(event, holonId, lensName)` → write to storage
+- `publishActivityPub(object, holonId, lensName)` → write to storage
+- `querySocial(holonId, options)` → filter by protocol and access level
+
+**Dependencies**: T036 (storage), T039 (crypto for signatures)
+**Acceptance**: Unit tests (T031) and contract tests (T015) pass
+
+---
+
+### T041: Implement subscriptions module
+**File**: `src/subscriptions/manager.js`
+**Description**: Implement subscription management:
+- `subscribe(holonId, lensName, callback, options)` → subscription object
+- Gun `.on()` listener with throttle and filter
+- Callback invocation on data changes
+- `unsubscribe()` cleanup (remove listener)
+- Subscription registry for tracking active subscriptions
+
+**Dependencies**: T036 (storage)
+**Acceptance**: Unit tests (T033) and contract tests (T013) pass
+
+---
+
+### T041.5: Implement hierarchical upcast module
+**File**: `src/hierarchical/upcast.js`
+**Description**: Implement hierarchical aggregation with operations (FR-025 to FR-027):
+- `upcast(holonId, lensName, dataId, options)` → boolean
+- Operation modes: 'summarize' (count), 'aggregate' (merge objects), 'concatenate' (arrays)
+- Traverse H3 parent hierarchy up to maxLevel (default: 3)
+- Write holograms to parent holons referencing original data
+- Error handling for noospheric holons (no spatial hierarchy)
+- Integration with spatial module for parent traversal
+- Integration with storage module for hologram creation
+
+**Dependencies**: T035 (spatial), T036 (storage), T038 (federation for holograms)
+**Acceptance**: Unit tests (T033.5) and contract tests (T012) pass
+
+---
+
+## Phase 3.4: Integration & Public API
+
+### T042: Wire up public API exports
+**File**: `src/index.js`
+**Description**: Create main entry point exporting HoloSphere class with all methods:
+- Import and attach all modules to HoloSphere prototype
+- Core: constructor
+- Spatial: toHolon, getParents, getChildren, isValidH3
+- Data: write, read, update, delete, writeGlobal, readGlobal, updateGlobal, deleteGlobal
+- Schema: setSchema, getSchema, clearSchema
+- Federation: federate, getFederatedData, unfederate
+- Hierarchical: upcast
+- Subscriptions: subscribe
+- Crypto: sign, verify, issueCapability, verifyCapability
+- Social: publishNostr, publishActivityPub, querySocial
+- Utils: metrics
+- Export error classes: ValidationError, AuthorizationError, HolosphereError
+
+**Dependencies**: All modules (T034-T041.5)
+**Acceptance**: All contract tests (T007-T016) pass
+
+---
+
+### T043: Verify all integration tests pass
+**Files**: `tests/integration/scenario-*.test.js`
+**Description**: Run all integration tests and verify end-to-end workflows:
+- All 9 quickstart scenarios execute successfully
+- No test failures, no errors
+- Data persists correctly with radisk
+- Federation works across dimensions
+- Authorization enforced properly
+
+**Dependencies**: T042 (public API complete)
+**Acceptance**: All integration tests (T017-T025) pass
+
+---
+
+## Phase 3.5: Build, Distribution & Polish
+
+### T044: Configure ESM build
+**File**: `vite.config.js` (already created in T003, update if needed)
+**Description**: Ensure ESM build configuration:
+- Entry: `src/index.js`
+- Output: `dist/esm/holosphere.js`
+- Format: `es`
+- Tree-shakeable exports
+- Sourcemaps
+
+**Dependencies**: T043 (tests passing)
+**Acceptance**: `npm run build` creates `dist/esm/holosphere.js`
+
+---
+
+### T045: Configure CommonJS build
+**File**: `vite.config.js` (update)
+**Description**: Add CommonJS build target:
+- Output: `dist/cjs/holosphere.cjs`
+- Format: `cjs`
+- Externalize peer dependencies (optional)
+
+**Dependencies**: T044
+**Acceptance**: `npm run build` creates `dist/cjs/holosphere.cjs`
+
+---
+
+### T046: Configure CDN bundle with radisk
+**File**: `vite.config.js` (update)
+**Description**: Add UMD bundle for CDN:
+- Output: `dist/cdn/holosphere.min.js`
+- Format: `umd`
+- Global name: `HoloSphere`
+- Bundle ALL dependencies (Gun, h3-js, @noble/curves, Ajv, radisk)
+- Minify with terser
+
+**Dependencies**: T045
+**Acceptance**: `npm run build` creates `dist/cdn/holosphere.min.js`
+
+---
+
+### T047: Validate bundle size (<1MB target)
+**File**: Create `scripts/check-bundle-size.js`
+**Description**: Script to validate bundle size:
+- Read `dist/cdn/holosphere.min.js` size
+- Calculate gzipped size
+- Assert <1MB (1,048,576 bytes)
+- Exit with error if exceeds limit
+- Add to `npm test` script
+
+**Dependencies**: T046
+**Acceptance**: Bundle size <1MB minified+gzipped
+
+---
+
+### T048: Configure package.json exports
+**File**: `package.json` (update)
+**Description**: Add package exports configuration:
+```json
+{
+  "type": "module",
+  "main": "./dist/cjs/holosphere.cjs",
+  "module": "./dist/esm/holosphere.js",
+  "browser": "./dist/cdn/holosphere.min.js",
+  "exports": {
+    ".": {
+      "import": "./dist/esm/holosphere.js",
+      "require": "./dist/cjs/holosphere.cjs"
+    }
+  }
+}
+```
+
+**Dependencies**: T046
+**Acceptance**: `npm pack` creates package with correct exports
+
+---
+
+### T049: [P] Generate TypeScript definitions
+**File**: Create `scripts/generate-types.js` or use `tsc`
+**Description**: Generate TypeScript `.d.ts` files:
+- Create type definitions for HoloSphere class
+- Define all method signatures with parameter types
+- Export error class types
+- Include JSDoc comments from source
+- Output to `dist/types/index.d.ts`
+- Add `"types": "./dist/types/index.d.ts"` to package.json
+
+**Dependencies**: T042 (source complete)
+**Acceptance**: `dist/types/index.d.ts` exists with all API types
+
+---
+
+### T050: [P] Verify code coverage ≥80%
+**File**: N/A (run coverage report)
+**Description**: Run `npm run test:coverage` and verify:
+- Line coverage ≥80% across all modules
+- All modules have unit tests
+- Contract tests cover 100% of public API
+- Integration tests cover all user stories
+- Generate HTML coverage report
+
+**Dependencies**: T043 (all tests passing)
+**Acceptance**: Coverage report shows ≥80% line coverage
+
+---
+
+### T051: [P] Create README.md with quickstart
+**File**: `README.md`
+**Description**: Create comprehensive README:
+- Project description
+- Installation (npm, CDN)
+- Quick start example (basic usage)
+- Link to full API documentation
+- Link to quickstart scenarios
+- Contributing guidelines
+- License (specify)
+
+**Dependencies**: T048 (package configured)
+**Acceptance**: README covers installation and basic usage
+
+---
+
+### T052: [P] Performance validation
+**File**: Create `tests/performance/benchmark.test.js`
+**Description**: Performance tests:
+- Initialization time <50ms (without crypto lazy load)
+- Write operation <20ms (avg)
+- Read operation <10ms (avg)
+- Subscription overhead <5ms
+- Hologram resolution <15ms (single level)
+
+**Dependencies**: T043
+**Acceptance**: All performance benchmarks meet targets
+
+---
+
+## Dependencies
+
+**Sequential Dependencies**:
+- Setup (T001-T006) → Tests (T007-T033) → Implementation (T034-T041) → Integration (T042-T043) → Build (T044-T052)
+
+**Module Dependencies**:
+- T035 (spatial), T036 (storage), T039 (crypto) depend on T034 (core)
+- T037 (schema) depends on T036 (storage)
+- T038 (federation) depends on T035 (spatial) and T036 (storage)
+- T040 (content) depends on T036 (storage) and T039 (crypto)
+- T041 (subscriptions) depends on T036 (storage)
+- T042 (public API) depends on all modules (T034-T041)
+
+**Test Dependencies**:
+- Contract tests (T007-T016) can run in parallel
+- Integration tests (T017-T025) can run in parallel
+- Unit tests (T026-T033) can run in parallel
+- All tests must be written before implementation begins
+
+**Build Dependencies**:
+- T045 (CJS) depends on T044 (ESM)
+- T046 (CDN) depends on T045 (CJS)
+- T047 (size check) depends on T046 (CDN)
+- T048 (exports) depends on T046 (all builds complete)
+
+---
+
+## Parallel Execution Examples
+
+### Launch all contract tests together (T007-T016):
+```bash
+# Use Task tool or run tests in parallel
+vitest run tests/contract/core.test.js &
+vitest run tests/contract/spatial.test.js &
+vitest run tests/contract/data.test.js &
+vitest run tests/contract/schema.test.js &
+vitest run tests/contract/federation.test.js &
+vitest run tests/contract/hierarchical.test.js &
+vitest run tests/contract/subscriptions.test.js &
+vitest run tests/contract/crypto.test.js &
+vitest run tests/contract/social.test.js &
+vitest run tests/contract/utils.test.js &
+wait
+```
+
+### Launch all integration tests together (T017-T025):
+```bash
+vitest run tests/integration/scenario-01-geographic-storage.test.js &
+vitest run tests/integration/scenario-02-federation.test.js &
+vitest run tests/integration/scenario-03-subscriptions.test.js &
+vitest run tests/integration/scenario-04-validation.test.js &
+vitest run tests/integration/scenario-05-hierarchy.test.js &
+vitest run tests/integration/scenario-06-social.test.js &
+vitest run tests/integration/scenario-07-persistence.test.js &
+vitest run tests/integration/scenario-08-authorization.test.js &
+vitest run tests/integration/scenario-09-cross-dimensional.test.js &
+wait
+```
+
+### Launch parallel unit tests (T026-T033):
+```bash
+vitest run tests/unit/core.test.js &
+vitest run tests/unit/spatial.test.js &
+vitest run tests/unit/storage.test.js &
+vitest run tests/unit/schema.test.js &
+vitest run tests/unit/federation.test.js &
+vitest run tests/unit/content.test.js &
+vitest run tests/unit/crypto.test.js &
+vitest run tests/unit/subscriptions.test.js &
+wait
+```
+
+### Launch parallel module implementations (T034, T035, T036, T039):
+```bash
+# Independent modules with no cross-dependencies
+# Task: "Implement core module in src/core/holosphere.js"
+# Task: "Implement spatial module in src/spatial/h3-operations.js (depends on core)"
+# Task: "Implement storage module in src/storage/gun-wrapper.js (depends on core)"
+# Task: "Implement crypto module in src/crypto/secp256k1.js (independent, lazy loaded)"
+```
+
+---
+
+## Notes
+
+- **[P] tasks** = Different files, no dependencies, safe to parallelize
+- **TDD Enforcement**: All tests (T007-T033) MUST be written and failing before implementation (T034-T041)
+- **Constitutional Compliance**: Every module has unit tests (per Constitution XI)
+- **Coverage Target**: ≥80% line coverage enforced in T050
+- **Commit Strategy**: Commit after each task or logical group
+- **Error Handling**: All modules must use structured logging (JSON format)
+
+---
+
+## Validation Checklist
+
+**Pre-Implementation Gates**:
+- [x] All contracts have corresponding tests (T007-T016)
+- [x] All entities have model/implementation tasks (9 entities → 8 modules)
+- [x] All tests come before implementation (Phase 3.2 before 3.3)
+- [x] Parallel tasks truly independent (verified file paths)
+- [x] Each task specifies exact file path
+- [x] No [P] task modifies same file as another [P] task
+
+**Post-Implementation Gates**:
+- [ ] All contract tests pass (run after T042)
+- [ ] All integration tests pass (run after T043)
+- [ ] All unit tests pass (continuous)
+- [ ] Code coverage ≥80% (T050)
+- [ ] Bundle size <1MB (T047)
+- [ ] Performance benchmarks met (T052)
+
+---
+
+## Summary
+
+**Total Tasks**: 52 (T001-T052)
+**Parallel Opportunities**:
+- 10 contract tests [P]
+- 9 integration tests [P]
+- 8 unit tests [P]
+- 4 module implementations [P] (core, spatial, storage, crypto initially)
+- 3 polish tasks [P] (types, coverage, docs)
+
+**Estimated Phases**:
+1. Setup: 6 tasks (sequential)
+2. Tests: 27 tasks (mostly parallel)
+3. Implementation: 9 tasks (parallel with dependencies)
+4. Integration: 2 tasks (sequential)
+5. Build & Polish: 8 tasks (mixed)
+
+**Critical Path**: Setup → Tests → Core modules → Storage → Federation → Public API → Integration → Build
+
+**Next Step**: Begin with T001 (Initialize npm project)