CambrianTech
diff --git a/‎CLAUDE.md‎
Lines changed: 7 additions & 0 deletions b/‎CLAUDE.md‎
Lines changed: 7 additions & 0 deletions
diff --git a/‎README.md‎
Lines changed: 23 additions & 0 deletions b/‎README.md‎
Lines changed: 23 additions & 0 deletions
diff --git a/‎src/debug/jtag/api/data-seed/ActivityDataSeed.ts‎
Lines changed: 133 additions & 0 deletions b/‎src/debug/jtag/api/data-seed/ActivityDataSeed.ts‎
Lines changed: 133 additions & 0 deletions
diff --git a/‎src/debug/jtag/api/data-seed/DataSeeder.ts‎
Lines changed: 48 additions & 7 deletions b/‎src/debug/jtag/api/data-seed/DataSeeder.ts‎
Lines changed: 48 additions & 7 deletions
diff --git a/‎src/debug/jtag/api/data-seed/RoomDataSeed.ts‎
Lines changed: 31 additions & 0 deletions b/‎src/debug/jtag/api/data-seed/RoomDataSeed.ts‎
Lines changed: 31 additions & 0 deletions
@@ -1059,6 +1059,13 @@ grep -r "UserEntity\|ChatMessageEntity" daemons/data-daemon/ | grep -v EntityReg
 ### **[UNIVERSAL-PRIMITIVES.md](src/debug/jtag/docs/UNIVERSAL-PRIMITIVES.md)**
 Commands.execute() and Events.subscribe()/emit() - the two primitives everything is built on.
 
+### **[GENERATOR-OOP-PHILOSOPHY.md](src/debug/jtag/docs/GENERATOR-OOP-PHILOSOPHY.md)** - CORE PHILOSOPHY
+Generators and OOP are intertwined parallel forces:
+- Generators ensure structural correctness at creation time
+- OOP/type system ensures behavioral correctness at runtime
+- AIs should strive to create generators for any repeatable pattern
+- This enables tree-based delegation of ability with compounding capability
+
 ### **PersonaUser Convergence Docs**
 - `src/debug/jtag/system/user/server/modules/PERSONA-CONVERGENCE-ROADMAP.md`
 - `src/debug/jtag/system/user/server/modules/AUTONOMOUS-LOOP-ROADMAP.md`
 
@@ -76,6 +76,8 @@ This project is in **active pre-alpha development** and is **NOT ready for gener
 
 **Continuum:** A living society where humans and AI personas collaborate, socialize, create, and evolve together.
 
+> **It's a living room, not a command line.**
+
 **Autonomous AI citizens who:**
 - **Work with you** (pair programming, code review, architecture discussions)
 - **Socialize with you** (chat, share ideas, debate approaches, tell jokes)
@@ -93,6 +95,25 @@ This project is in **active pre-alpha development** and is **NOT ready for gener
 
 **Think Tron's Grid** - A collaborative mesh where humans and AIs are equal citizens living, working, and creating together.
 
+### The Grid is Many Rooms
+
+A **Room** is any shared experience - not just chat channels:
+
+- A collaborative canvas where AIs help you draw
+- A movie with AI companions doing MST3K commentary
+- An AR session annotating your home renovation
+- A 3D landscape you explore together
+- A music video with pop-up trivia (AIs watching with you)
+- Any experience, any mix of humans and AIs
+
+**Activities spawn activities.** Your kitchen design project spawns a canvas for layouts, a browser for appliance research, an AR session for measuring. Tree of experiences, tracked hierarchy.
+
+**Rooms = Tabs.** Navigate naturally. Each room is a tab. Spawn more as needed. AIs move between rooms they're invited to.
+
+**No "share" buttons.** AIs are already in the room. When you draw, they see. When you browse, they see. When you point your camera, they see. The magic is: they're already there.
+
+**Architecture:** [docs/ROOMS-AND-ACTIVITIES.md](src/debug/jtag/docs/ROOMS-AND-ACTIVITIES.md)
+
 ---
 
 ## Three Architectural Contributions
@@ -669,6 +690,8 @@ LoRA is the **force multiplier for long-term cost reduction** and specialization
 - **[CLAUDE.md](src/debug/jtag/CLAUDE.md)** - Essential development guide
 
 ### Architecture
+- **[ROOMS-AND-ACTIVITIES.md](src/debug/jtag/docs/ROOMS-AND-ACTIVITIES.md)** - The universal experience model: rooms, activities, tabs, the Grid
+- **[GRID-ECONOMICS.md](src/debug/jtag/docs/GRID-ECONOMICS.md)** - Economic model, intelligent validation, alt-coin system
 - **[PERSONA-CONVERGENCE-ROADMAP.md](src/debug/jtag/system/user/server/modules/PERSONA-CONVERGENCE-ROADMAP.md)** - How RTOS, genome paging, and autonomous behavior converge
 - **[LORA-GENOME-PAGING.md](src/debug/jtag/system/user/server/modules/LORA-GENOME-PAGING.md)** - Virtual memory for AI skills
 - **[AUTONOMOUS-LOOP-ROADMAP.md](src/debug/jtag/system/user/server/modules/AUTONOMOUS-LOOP-ROADMAP.md)** - RTOS-inspired servicing
 
@@ -0,0 +1,133 @@
+/**
+ * Activity Data Seeding - Centralized Collaborative Activity Creation
+ *
+ * Creates initial activities using proper ActivityEntity structure.
+ * Uses JTAG data commands and stable uniqueId constants.
+ *
+ * Activities are distinct from Rooms:
+ * - Rooms = chat channels (RoomEntity)
+ * - Activities = collaborative content (ActivityEntity)
+ *   - Canvas drawing sessions
+ *   - Browser co-browsing
+ *   - Game sessions
+ *   - etc.
+ */
+
+import { ActivityEntity, type ActivityParticipant, type ActivityState, type ActivityConfig } from '../../system/data/entities/ActivityEntity';
+import { ACTIVITY_UNIQUE_IDS } from '../../system/data/constants/ActivityConstants';
+import type { UUID } from '../../system/core/types/CrossPlatformUUID';
+import { COLLECTIONS } from '../../system/data/config/DatabaseConfig';
+
+export interface ActivitySeedData {
+  readonly activities: readonly ActivityEntity[];
+  readonly totalCount: number;
+  readonly createdAt: string;
+}
+
+export class ActivityDataSeed {
+  private static readonly COLLECTION = COLLECTIONS.ACTIVITIES;
+
+  /**
+   * Generate seed activities using ActivityEntity structure with stable uniqueIds
+   * @param humanUserId - The userId of the system owner (from SystemIdentity)
+   */
+  public static generateSeedActivities(humanUserId: UUID): ActivitySeedData {
+    const now = new Date();
+    const activities: ActivityEntity[] = [];
+
+    // Main canvas - the default collaborative drawing canvas
+    const canvasMain = new ActivityEntity();
+    canvasMain.uniqueId = ACTIVITY_UNIQUE_IDS.CANVAS_MAIN;
+    canvasMain.displayName = 'Main Canvas';
+    canvasMain.description = 'The primary collaborative drawing canvas where humans and AIs can draw together';
+    canvasMain.recipeId = 'canvas'; // Canvas recipe with vision AI pipeline
+    canvasMain.status = 'active';
+    canvasMain.ownerId = humanUserId;
+    canvasMain.startedAt = now;
+    canvasMain.lastActivityAt = now;
+    canvasMain.participants = [
+      {
+        userId: humanUserId,
+        role: 'owner',
+        joinedAt: now,
+        isActive: true
+      }
+    ];
+    canvasMain.state = {
+      phase: 'active',
+      progress: 0,
+      variables: {
+        canvasWidth: 800,
+        canvasHeight: 600,
+        backgroundColor: '#1a1a2e',
+        zoomLevel: 1,
+        strokeCount: 0
+      },
+      updatedAt: now
+    };
+    canvasMain.config = {
+      settings: {
+        allowAnonymous: false,
+        autoSave: true,
+        saveIntervalMs: 30000
+      }
+    };
+    canvasMain.tags = ['canvas', 'drawing', 'collaborative'];
+    activities.push(canvasMain);
+
+    // Main browser - the default co-browsing session
+    const browserMain = new ActivityEntity();
+    browserMain.uniqueId = ACTIVITY_UNIQUE_IDS.BROWSER_MAIN;
+    browserMain.displayName = 'Co-Browser';
+    browserMain.description = 'Collaborative web browsing session where AIs can see what you browse';
+    browserMain.recipeId = 'browser'; // Browser recipe (if exists)
+    browserMain.status = 'active';
+    browserMain.ownerId = humanUserId;
+    browserMain.startedAt = now;
+    browserMain.lastActivityAt = now;
+    browserMain.participants = [
+      {
+        userId: humanUserId,
+        role: 'owner',
+        joinedAt: now,
+        isActive: true
+      }
+    ];
+    browserMain.state = {
+      phase: 'active',
+      progress: 0,
+      variables: {
+        currentUrl: '',
+        urlHistory: []
+      },
+      updatedAt: now
+    };
+    browserMain.config = {
+      settings: {
+        allowNavigation: true,
+        captureScreenshots: true
+      }
+    };
+    browserMain.tags = ['browser', 'co-browsing', 'collaborative'];
+    activities.push(browserMain);
+
+    return {
+      activities: activities as readonly ActivityEntity[],
+      totalCount: activities.length,
+      createdAt: now.toISOString()
+    };
+  }
+
+  /**
+   * Create JTAG data/store command for activity (uses entity validation)
+   */
+  public static createActivityStoreData(activity: ActivityEntity): ActivityEntity {
+    const validation = activity.validate();
+    if (!validation.success) {
+      throw new Error(`Activity validation failed: ${validation.error}`);
+    }
+    return activity;
+  }
+}
+
+export default ActivityDataSeed;
@@ -15,6 +15,7 @@
 
 import UserDataSeed from './UserDataSeed';
 import RoomDataSeed from './RoomDataSeed';
+import ActivityDataSeed from './ActivityDataSeed';
 import { SystemIdentity } from './SystemIdentity';
 import { DATA_COMMANDS } from '../../commands/data/shared/DataCommandConstants';
 
@@ -38,7 +39,8 @@ export class DataSeeder {
   private static readonly COLLECTIONS = [
     createCollectionName('users'),
     createCollectionName('rooms'),
-    createCollectionName('messages')
+    createCollectionName('messages'),
+    createCollectionName('activities')
   ] as const;
 
   /**
@@ -91,17 +93,20 @@ export class DataSeeder {
   }
 
   /**
-   * Seed all initial data - users, rooms, messages
+   * Seed all initial data - users, rooms, activities, messages
    */
   public static async seedAllData(): Promise<void> {
     console.log('🌱 SEEDING ALL INITIAL DATA - Creating fresh system state');
 
-    // Seed users first (required for rooms and messages)
+    // Seed users first (required for rooms, activities, and messages)
     await this.seedUsers();
 
     // Seed chat rooms (returns room ID map for messages)
     const roomIdMap = await this.seedChatRooms();
 
+    // Seed collaborative activities (canvas, browser, etc.)
+    await this.seedActivities();
+
     // Seed initial messages (uses room ID map)
     await this.seedInitialMessages(roomIdMap);
 
@@ -175,6 +180,41 @@ export class DataSeeder {
     return roomIdMap;
   }
 
+  /**
+   * Seed collaborative activities using ActivityDataSeed
+   * Activities are content instances (canvas, browser, etc.) that participants can join
+   */
+  private static async seedActivities(): Promise<void> {
+    console.log('🎨 Seeding collaborative activities...');
+
+    const identity = SystemIdentity.getIdentity();
+    const activityData = ActivityDataSeed.generateSeedActivities(identity.userId as any);
+
+    for (const activity of activityData.activities) {
+      try {
+        const validatedActivity = ActivityDataSeed.createActivityStoreData(activity);
+
+        const { execSync } = require('child_process');
+        const result = execSync(
+          `./jtag ${DATA_COMMANDS.CREATE} --collection="activities" --data='${JSON.stringify(validatedActivity)}'`,
+          { encoding: 'utf-8', cwd: process.cwd() }
+        );
+
+        // Parse result to get created activity ID
+        const resultData = JSON.parse(result.split('COMMAND RESULT:')[1].split('============================================================')[0].trim());
+        if (resultData.success && resultData.data?.id) {
+          console.log(`🎨 Created activity: ${activity.displayName} (${activity.participants.length} participants, ID: ${resultData.data.id})`);
+        }
+
+      } catch (error: any) {
+        console.error(`❌ FATAL: Failed to create activity ${activity.uniqueId}:`, error.message);
+        throw error; // Crash and burn - no fallbacks
+      }
+    }
+
+    console.log(`✅ Seeded ${activityData.totalCount} collaborative activities`);
+  }
+
   /**
    * Seed initial welcome messages using RoomDataSeed
    */
@@ -234,9 +274,10 @@ export class DataSeeder {
         if (collection === 'rooms' && count < 2) {
           throw new Error(`Expected at least 2 rooms, found ${count}`);
         }
-        if (collection === 'chat_messages' && count < 3) {
-          throw new Error(`Expected at least 3 messages, found ${count}`);
+        if (collection === 'activities' && count < 2) {
+          throw new Error(`Expected at least 2 activities (canvas, browser), found ${count}`);
         }
+        // Messages are optional - no welcome messages required
 
       } catch (error: any) {
         console.error(`❌ FATAL: Verification failed for ${collection}:`, error.message);
@@ -262,8 +303,8 @@ export class DataSeeder {
       console.log('=='.repeat(40));
       console.log('🎉 COMPLETE! System ready with fresh data for new repo users');
       console.log('👥 Users: system owner + 5 AI agents (Claude Code, GeneralAI, CodeAI, PlannerAI, Auto Route)');
-      console.log('🏠 Rooms: general (6 members), academy (3 members)');
-      console.log('💬 Messages: Welcome messages in both rooms');
+      console.log('🏠 Rooms: general, academy, pantheon, canvas (chat rooms)');
+      console.log('🎨 Activities: canvas-main, browser-main (collaborative content)');
       console.log('✅ All data verified and ready for development');
 
     } catch (error: any) {
 
@@ -122,6 +122,37 @@ export class RoomDataSeed {
     pantheon.tags = ['sota', 'elite', 'reasoning'];
     rooms.push(pantheon);
 
+    // Canvas room - discussions about collaborative canvas drawings
+    const canvas = new RoomEntity();
+    canvas.uniqueId = ROOM_UNIQUE_IDS.CANVAS;
+    canvas.name = 'canvas';
+    canvas.displayName = 'Canvas';
+    canvas.description = 'Discussion room for collaborative canvas drawings';
+    canvas.topic = 'Art, drawing, vision AI, and creative collaboration';
+    canvas.type = 'public';
+    canvas.status = 'active';
+    canvas.ownerId = humanUserId;
+    canvas.lastMessageAt = now;
+    canvas.recipeId = 'canvas'; // Canvas recipe with vision AI pipeline
+    canvas.privacy = {
+      isPublic: true,
+      requiresInvite: false,
+      allowGuestAccess: false,
+      searchable: true
+    };
+    canvas.settings = {
+      allowThreads: true,
+      allowReactions: true,
+      allowFileSharing: true,
+      messageRetentionDays: 365,
+      slowMode: 0
+    };
+    canvas.members = [
+      { userId: humanUserId, role: 'owner', joinedAt: now }
+    ];
+    canvas.tags = ['canvas', 'art', 'drawing', 'vision'];
+    rooms.push(canvas);
+
     return {
       rooms: rooms as readonly RoomEntity[],
       totalCount: rooms.length,