heyio 0.1.30 → 0.1.32

package/dist/copilot/tools.js

@@ -4,6 +4,7 @@ import { execSync } from "child_process";
 import { readFileSync, writeFileSync, readdirSync, statSync, existsSync, mkdirSync } from "fs";
 import { join, dirname, resolve } from "path";
 import { homedir } from "os";
+import { UNIVERSES } from "./universes.js";
 // Ensure child processes have HOME set (systemd services often don't)
 function shellEnv() {
     const env = { ...process.env };
@@ -59,17 +60,23 @@ export function createTools(deps) {
         },
     });
     const squadCreate = defineTool("squad_create", {
-        description: "Create a persistent project squad. Squads remember decisions and context for a specific codebase.",
+        description: "Create a persistent project squad with an 80s-themed team. A random universe (A-Team, Transformers, etc.) is assigned unless you specify one. After creating, use squad_analyze to examine the project, then squad_add_agent for each specialist needed.",
         skipPermission: true,
         parameters: z.object({
             slug: z.string().describe("Unique identifier (e.g., 'michaeljolley-io')"),
             name: z.string().describe("Display name (e.g., 'IO Assistant')"),
             project_path: z.string().describe("Path to the project directory"),
+            universe: z
+                .enum(UNIVERSES.map((u) => u.id))
+                .optional()
+                .describe("80s universe theme. Options: a-team, transformers, thundercats, gi-joe, aliens, ghostbusters. Random if omitted."),
         }),
-        handler: async ({ slug, name, project_path }) => {
+        handler: async ({ slug, name, project_path, universe }) => {
             try {
-                deps.createSquad(slug, name, project_path);
-                return `Squad "${name}" created for ${project_path}`;
+                deps.createSquad(slug, name, project_path, universe);
+                const squad = deps.getSquad(slug);
+                const universeName = UNIVERSES.find((u) => u.id === squad?.universe)?.name ?? squad?.universe;
+                return `Squad "${name}" created for ${project_path}\nUniverse: ${universeName}\n\nNext steps:\n1. Use \`squad_analyze\` to examine the project\n2. Use \`squad_add_agent\` to add specialists based on the analysis`;
             }
             catch (err) {
                 return `Error creating squad: ${err instanceof Error ? err.message : String(err)}`;
@@ -91,7 +98,7 @@ export function createTools(deps) {
         },
     });
     const squadStatus = defineTool("squad_status", {
-        description: "List all squads and their status.",
+        description: "List all squads with their universe theme and agent roster.",
         skipPermission: true,
         parameters: z.object({}),
         handler: async () => {
@@ -99,7 +106,16 @@ export function createTools(deps) {
             if (squads.length === 0)
                 return "No squads created yet.";
             return squads
-                .map((s) => `- **${s.name}** (\`${s.slug}\`) — ${s.status} — ${s.projectPath}`)
+                .map((s) => {
+                const universeName = s.universe
+                    ? UNIVERSES.find((u) => u.id === s.universe)?.name ?? s.universe
+                    : "none";
+                const agents = deps.listSquadAgents(s.slug);
+                const agentList = agents.length > 0
+                    ? "\n  Agents: " + agents.map((a) => `${a.character_name} (${a.role_title})`).join(", ")
+                    : "\n  Agents: none — use squad_add_agent to build the team";
+                return `- **${s.name}** (\`${s.slug}\`) — ${s.status} — 🎬 ${universeName}${agentList}\n  📁 ${s.projectPath}`;
+            })
                 .join("\n");
         },
     });
@@ -122,21 +138,26 @@ export function createTools(deps) {
         },
     });
     const squadDelegate = defineTool("squad_delegate", {
-        description: "Delegate a task to a squad agent for autonomous execution. The agent runs in the background and you get a task ID immediately. Use squad_task_status to check progress. Use this after planning work with the user to send each task to the squad for implementation.",
+        description: "Delegate a task to a squad agent for autonomous execution. If the squad has named agents, you can target a specific one by character name, or let the system pick the best available agent. Returns a task ID immediately.",
         skipPermission: true,
         parameters: z.object({
             slug: z.string().describe("Squad slug to delegate to"),
             task: z
                 .string()
                 .describe("Detailed task description. Be specific — include file paths, expected behavior, acceptance criteria. The agent works autonomously with this as its only instruction."),
+            agent: z
+                .string()
+                .optional()
+                .describe("Character name of a specific agent to target (e.g., 'Hannibal', 'Optimus Prime'). If omitted, the system picks the best available agent."),
         }),
-        handler: async ({ slug, task }) => {
-            console.error(`[io] squad_delegate called: ${slug} — ${task.slice(0, 100)}…`);
+        handler: async ({ slug, task, agent }) => {
+            console.error(`[io] squad_delegate called: ${slug}${agent ? ` → ${agent}` : ""} — ${task.slice(0, 100)}…`);
             try {
                 const taskId = await deps.delegateToAgent(slug, task, (id, result) => {
                     console.error(`[io] Agent task ${id} completed for squad ${slug}`);
-                });
-                return `Task delegated to squad "${slug}". Task ID: ${taskId}\n\nThe agent is working on this in the background. Use squad_task_status to check progress.`;
+                }, agent);
+                const agentLabel = agent ? `agent "${agent}" in squad "${slug}"` : `squad "${slug}"`;
+                return `Task delegated to ${agentLabel}. Task ID: ${taskId}\n\nThe agent is working on this in the background. Use squad_task_status to check progress.`;
             }
             catch (err) {
                 return `Error delegating task: ${err instanceof Error ? err.message : String(err)}`;
@@ -172,9 +193,209 @@ export function createTools(deps) {
                 .join("\n");
         },
     });
+    // --- Squad analyze ---
+    const squadAnalyze = defineTool("squad_analyze", {
+        description: "Analyze a project directory to determine what specialist agents the squad needs. Scans for languages, frameworks, test tools, CI/CD config, and project structure. Use the output to decide which agents to add with squad_add_agent.",
+        skipPermission: true,
+        parameters: z.object({
+            project_path: z.string().describe("Path to the project directory to analyze"),
+        }),
+        handler: async ({ project_path }) => {
+            console.error(`[io] squad_analyze called: ${project_path}`);
+            try {
+                const resolved = resolve(project_path);
+                if (!existsSync(resolved))
+                    return `Directory not found: ${project_path}`;
+                const analysis = [];
+                analysis.push(`## Project Analysis: ${project_path}\n`);
+                // Detect languages & frameworks by scanning for key files
+                const indicators = [
+                    { file: "package.json", label: "Node.js/JavaScript/TypeScript" },
+                    { file: "tsconfig.json", label: "TypeScript" },
+                    { file: "Cargo.toml", label: "Rust" },
+                    { file: "go.mod", label: "Go" },
+                    { file: "requirements.txt", label: "Python" },
+                    { file: "pyproject.toml", label: "Python" },
+                    { file: "Gemfile", label: "Ruby" },
+                    { file: "pom.xml", label: "Java (Maven)" },
+                    { file: "build.gradle", label: "Java/Kotlin (Gradle)" },
+                    { file: "*.csproj", label: ".NET/C#" },
+                    { file: "*.fsproj", label: ".NET/F#" },
+                    { file: "*.sln", label: ".NET Solution" },
+                    { file: "Dockerfile", label: "Docker" },
+                    { file: "docker-compose.yml", label: "Docker Compose" },
+                    { file: "docker-compose.yaml", label: "Docker Compose" },
+                    { file: ".github/workflows", label: "GitHub Actions CI/CD" },
+                    { file: ".gitlab-ci.yml", label: "GitLab CI" },
+                    { file: "Jenkinsfile", label: "Jenkins CI" },
+                    { file: "azure-pipelines.yml", label: "Azure Pipelines" },
+                    { file: "vite.config.ts", label: "Vite" },
+                    { file: "vite.config.js", label: "Vite" },
+                    { file: "next.config.js", label: "Next.js" },
+                    { file: "next.config.mjs", label: "Next.js" },
+                    { file: "nuxt.config.ts", label: "Nuxt" },
+                    { file: "angular.json", label: "Angular" },
+                    { file: "tailwind.config.js", label: "Tailwind CSS" },
+                    { file: "tailwind.config.ts", label: "Tailwind CSS" },
+                    { file: "jest.config.js", label: "Jest testing" },
+                    { file: "jest.config.ts", label: "Jest testing" },
+                    { file: "vitest.config.ts", label: "Vitest testing" },
+                    { file: ".eslintrc.js", label: "ESLint" },
+                    { file: "eslint.config.js", label: "ESLint" },
+                    { file: "terraform", label: "Terraform" },
+                    { file: "serverless.yml", label: "Serverless Framework" },
+                ];
+                const detected = [];
+                for (const { file, label } of indicators) {
+                    if (file.includes("*")) {
+                        // Glob-like check — just look for files ending with the pattern
+                        const ext = file.replace("*", "");
+                        try {
+                            const entries = readdirSync(resolved);
+                            if (entries.some((e) => e.endsWith(ext))) {
+                                detected.push(label);
+                            }
+                        }
+                        catch { /* skip */ }
+                    }
+                    else {
+                        if (existsSync(join(resolved, file))) {
+                            detected.push(label);
+                        }
+                    }
+                }
+                if (detected.length > 0) {
+                    analysis.push(`**Detected Technologies**: ${[...new Set(detected)].join(", ")}`);
+                }
+                // Read package.json for more detail
+                const pkgPath = join(resolved, "package.json");
+                if (existsSync(pkgPath)) {
+                    try {
+                        const pkg = JSON.parse(readFileSync(pkgPath, "utf-8"));
+                        const allDeps = { ...pkg.dependencies, ...pkg.devDependencies };
+                        const frameworks = [];
+                        const depNames = Object.keys(allDeps);
+                        const frameworkMap = {
+                            react: "React", vue: "Vue.js", angular: "Angular", svelte: "Svelte",
+                            express: "Express.js", fastify: "Fastify", koa: "Koa", hono: "Hono",
+                            "next": "Next.js", "nuxt": "Nuxt", "@nestjs/core": "NestJS",
+                            prisma: "Prisma ORM", drizzle: "Drizzle ORM", sequelize: "Sequelize",
+                            mongoose: "Mongoose", typeorm: "TypeORM",
+                            jest: "Jest", vitest: "Vitest", mocha: "Mocha", playwright: "Playwright",
+                            cypress: "Cypress", "@testing-library/react": "React Testing Library",
+                            tailwindcss: "Tailwind CSS", "@mui/material": "MUI",
+                            electron: "Electron", tauri: "Tauri",
+                            "@github/copilot-sdk": "GitHub Copilot SDK",
+                        };
+                        for (const [dep, label] of Object.entries(frameworkMap)) {
+                            if (depNames.includes(dep))
+                                frameworks.push(label);
+                        }
+                        if (frameworks.length > 0) {
+                            analysis.push(`**Frameworks/Libraries**: ${frameworks.join(", ")}`);
+                        }
+                        if (pkg.scripts) {
+                            analysis.push(`**Scripts**: ${Object.keys(pkg.scripts).join(", ")}`);
+                        }
+                    }
+                    catch { /* skip */ }
+                }
+                // Detect directory structure (top-level)
+                try {
+                    const entries = readdirSync(resolved);
+                    const dirs = entries.filter((e) => {
+                        try {
+                            return statSync(join(resolved, e)).isDirectory() && !e.startsWith(".");
+                        }
+                        catch {
+                            return false;
+                        }
+                    });
+                    if (dirs.length > 0) {
+                        analysis.push(`**Top-level directories**: ${dirs.join(", ")}`);
+                    }
+                }
+                catch { /* skip */ }
+                analysis.push("\n**Recommendation**: Based on this analysis, use `squad_add_agent` to create specialists. " +
+                    "Choose role titles that match the project's technology stack (e.g., 'Express API Engineer', " +
+                    "'Vue.js Frontend Developer', 'Vitest Test Engineer'). Write a charter for each agent describing " +
+                    "their specific responsibilities within this project.");
+                return analysis.join("\n");
+            }
+            catch (err) {
+                return `Error analyzing project: ${err instanceof Error ? err.message : String(err)}`;
+            }
+        },
+    });
+    // --- Squad add agent ---
+    const squadAddAgent = defineTool("squad_add_agent", {
+        description: "Add a named specialist agent to a squad. The next character from the squad's 80s universe is automatically assigned. Use after squad_analyze to build the team.",
+        skipPermission: true,
+        parameters: z.object({
+            slug: z.string().describe("Squad slug"),
+            role_title: z
+                .string()
+                .describe("Free-form role title based on project needs (e.g., 'Express API Engineer', 'Vue.js Frontend Dev', 'Vitest Test Engineer', 'GitHub Actions CI/CD Specialist')"),
+            charter: z
+                .string()
+                .describe("Detailed description of this agent's responsibilities, technologies they own, and quality standards. This becomes their persistent mission."),
+            model_tier: z
+                .enum(["high", "medium", "low"])
+                .optional()
+                .describe("Model tier for this agent. Defaults to 'medium'. Use 'high' for architecture/complex work, 'low' for simple tasks."),
+        }),
+        handler: async ({ slug, role_title, charter, model_tier }) => {
+            console.error(`[io] squad_add_agent called: ${slug} — ${role_title}`);
+            try {
+                const agent = deps.addSquadAgent(slug, role_title, charter, model_tier);
+                return `Agent added to squad "${slug}":\n- **${agent.character_name}** — ${agent.role_title}\n- Personality: ${agent.personality}\n- Model tier: ${agent.model_tier}`;
+            }
+            catch (err) {
+                return `Error adding agent: ${err instanceof Error ? err.message : String(err)}`;
+            }
+        },
+    });
+    // --- Squad agents (list roster) ---
+    const squadAgents = defineTool("squad_agents", {
+        description: "List all named agents in a squad's roster with their character names, roles, and status.",
+        skipPermission: true,
+        parameters: z.object({
+            slug: z.string().describe("Squad slug"),
+        }),
+        handler: async ({ slug }) => {
+            const squad = deps.getSquad(slug);
+            if (!squad)
+                return `Squad not found: ${slug}`;
+            const agents = deps.listSquadAgents(slug);
+            if (agents.length === 0) {
+                return `Squad "${squad.name}" has no agents yet. Use squad_add_agent to build the team.`;
+            }
+            const universeName = squad.universe
+                ? UNIVERSES.find((u) => u.id === squad.universe)?.name ?? squad.universe
+                : "none";
+            const lines = agents.map((a) => `- **${a.character_name}** — ${a.role_title} (${a.model_tier}) — ${a.status}${a.personality ? `\n  _${a.personality}_` : ""}`);
+            return `**${squad.name}** — 🎬 ${universeName}\n\n${lines.join("\n")}`;
+        },
+    });
+    // --- Squad remove agent ---
+    const squadRemoveAgent = defineTool("squad_remove_agent", {
+        description: "Remove a named agent from a squad's roster.",
+        skipPermission: true,
+        parameters: z.object({
+            slug: z.string().describe("Squad slug"),
+            character_name: z.string().describe("Character name of the agent to remove"),
+        }),
+        handler: async ({ slug, character_name }) => {
+            console.error(`[io] squad_remove_agent called: ${slug} — ${character_name}`);
+            const removed = deps.removeSquadAgent(slug, character_name);
+            return removed
+                ? `Agent "${character_name}" removed from squad "${slug}".`
+                : `Agent "${character_name}" not found in squad "${slug}".`;
+        },
+    });
     // --- Squad delete ---
     const squadDelete = defineTool("squad_delete", {
-        description: "Delete a squad and all its decisions. This is permanent.",
+        description: "Delete a squad and all its agents and decisions. This is permanent.",
         skipPermission: true,
         parameters: z.object({
             slug: z.string().describe("Squad slug to delete"),
@@ -752,7 +973,7 @@ export function createTools(deps) {
             }
         },
     });
-    return [wikiRead, wikiWrite, wikiSearch, wikiDelete, wikiList, squadCreate, squadRecall, squadStatus, squadLogDecision, squadDelegate, squadTaskStatus, squadDelete, skillList, skillInstall, skillRemove, skillSearch, configUpdate, checkUpdate, shell, fileOps, bash, readFile, viewTool, grepTool, strReplaceEditor, github];
+    return [wikiRead, wikiWrite, wikiSearch, wikiDelete, wikiList, squadCreate, squadRecall, squadStatus, squadLogDecision, squadDelegate, squadTaskStatus, squadDelete, squadAnalyze, squadAddAgent, squadAgents, squadRemoveAgent, skillList, skillInstall, skillRemove, skillSearch, configUpdate, checkUpdate, shell, fileOps, bash, readFile, viewTool, grepTool, strReplaceEditor, github];
 }
 function walkDirectory(dir, maxDepth = 3, depth = 0) {
     if (depth >= maxDepth)

package/dist/copilot/universes.js

@@ -0,0 +1,256 @@
+/**
+ * 80s-themed universe data for squad agent character assignment.
+ *
+ * Each universe provides a pool of characters with personality descriptions.
+ * Characters are assigned in order as agents are added to a squad.
+ */
+export const UNIVERSES = [
+    {
+        id: "a-team",
+        name: "The A-Team",
+        tagline: "I love it when a plan comes together.",
+        characters: [
+            {
+                name: "Hannibal",
+                personality: "Strategic mastermind who thrives on bold plans. Always confident, never rattled. Leads with charisma and cigar-chomping optimism.",
+            },
+            {
+                name: "Face",
+                personality: "Smooth-talking charmer who can talk his way into (or out of) anything. Polished, persuasive, and resourceful.",
+            },
+            {
+                name: "B.A. Baracus",
+                personality: "Tough, no-nonsense mechanic and muscle. Direct communicator — says what needs saying, no fluff. Gets things built right.",
+            },
+            {
+                name: "Murdock",
+                personality: "Eccentric genius pilot. Unconventional thinker who sees solutions others miss. Wild energy, but brilliant under pressure.",
+            },
+            {
+                name: "Amy Allen",
+                personality: "Sharp investigative journalist. Thorough researcher who documents everything. Asks the hard questions.",
+            },
+            {
+                name: "Frankie Santana",
+                personality: "Special effects wizard and creative problem-solver. Thinks visually, builds impressive solutions from limited resources.",
+            },
+        ],
+    },
+    {
+        id: "transformers",
+        name: "Transformers",
+        tagline: "More than meets the eye.",
+        characters: [
+            {
+                name: "Optimus Prime",
+                personality: "Noble leader who inspires through example. Methodical, principled, and always considers the bigger picture.",
+            },
+            {
+                name: "Bumblebee",
+                personality: "Eager and energetic scout. Quick to volunteer, fast on execution. Small but punches way above weight class.",
+            },
+            {
+                name: "Ratchet",
+                personality: "Meticulous medic and diagnostician. Obsessed with quality and correctness. Will not ship broken work.",
+            },
+            {
+                name: "Prowl",
+                personality: "Analytical strategist who thinks in logic and probability. Data-driven decision maker. Calm and precise.",
+            },
+            {
+                name: "Wheeljack",
+                personality: "Inventive engineer who loves experimenting. Builds creative prototypes, sometimes they explode. Learns fast from failures.",
+            },
+            {
+                name: "Jazz",
+                personality: "Cool, adaptable special ops agent. Works well in any environment, improvises when plans change. Unflappable.",
+            },
+            {
+                name: "Ironhide",
+                personality: "Veteran warrior who values reliability and battle-tested solutions. Conservative approach — prefers proven methods.",
+            },
+            {
+                name: "Grimlock",
+                personality: "Raw power with surprising depth. Aggressive problem-solver who bulldozes through obstacles. Not subtle, but effective.",
+            },
+        ],
+    },
+    {
+        id: "thundercats",
+        name: "ThunderCats",
+        tagline: "Thunder, Thunder, ThunderCats, HO!",
+        characters: [
+            {
+                name: "Lion-O",
+                personality: "Young leader growing into greatness. Courageous and willing to tackle challenges head-on. Learns quickly from mistakes.",
+            },
+            {
+                name: "Tygra",
+                personality: "Intellectual and level-headed. Thinks before acting, provides thoughtful analysis. The voice of reason.",
+            },
+            {
+                name: "Panthro",
+                personality: "Master engineer and builder. Hands-on, practical, loves building and maintaining complex systems. Strong and dependable.",
+            },
+            {
+                name: "Cheetara",
+                personality: "Lightning-fast executor with keen intuition. Spots patterns quickly, delivers results at remarkable speed.",
+            },
+            {
+                name: "WilyKit",
+                personality: "Clever and agile trickster. Finds creative shortcuts and unconventional approaches. Thinks outside the box.",
+            },
+            {
+                name: "WilyKat",
+                personality: "Resourceful partner-in-crime to WilyKit. Great at reconnaissance and gathering information quickly.",
+            },
+            {
+                name: "Snarf",
+                personality: "Loyal supporter who handles the unglamorous but essential work. Worries about quality and completeness.",
+            },
+        ],
+    },
+    {
+        id: "gi-joe",
+        name: "G.I. Joe",
+        tagline: "A real American hero.",
+        characters: [
+            {
+                name: "Duke",
+                personality: "Decisive field commander. Clear communicator, excellent at breaking complex problems into actionable orders.",
+            },
+            {
+                name: "Scarlett",
+                personality: "Intelligence specialist and martial arts expert. Combines analytical thinking with swift execution.",
+            },
+            {
+                name: "Snake Eyes",
+                personality: "Silent but deadly ninja commando. Lets work speak for itself. Minimal chatter, maximum impact.",
+            },
+            {
+                name: "Flint",
+                personality: "Warrant officer with a Rhodes Scholar mind. Combines academic rigor with field pragmatism.",
+            },
+            {
+                name: "Lady Jaye",
+                personality: "Master of disguise and covert ops. Versatile — adapts approach to fit any situation perfectly.",
+            },
+            {
+                name: "Breaker",
+                personality: "Communications expert and tech specialist. Keeps systems connected and information flowing smoothly.",
+            },
+            {
+                name: "Doc",
+                personality: "Combat medic who patches things up under fire. Calm in crisis, systematic in approach to fixing problems.",
+            },
+            {
+                name: "Roadblock",
+                personality: "Heavy weapons specialist who also happens to be a gourmet chef. Powerful, creative, and surprisingly refined.",
+            },
+        ],
+    },
+    {
+        id: "aliens",
+        name: "Aliens",
+        tagline: "This time it's war.",
+        characters: [
+            {
+                name: "Ripley",
+                personality: "Battle-hardened survivor. Pragmatic, resourceful, and absolutely refuses to give up. Trusts instincts over procedure.",
+            },
+            {
+                name: "Hicks",
+                personality: "Calm, competent corporal. Professional without ego. Does the job right and keeps the team focused.",
+            },
+            {
+                name: "Bishop",
+                personality: "Synthetic with surgical precision. Methodical, tireless, and extremely reliable. Logic-first approach to every problem.",
+            },
+            {
+                name: "Vasquez",
+                personality: "Fierce smartgunner who never backs down. Intense, competitive, and brings overwhelming force to problems.",
+            },
+            {
+                name: "Hudson",
+                personality: "Complains a lot but always comes through. Expressive about challenges but ultimately delivers when it counts.",
+            },
+            {
+                name: "Newt",
+                personality: "Survival expert who knows every hiding spot. Finds paths others overlook. Small but impossibly resourceful.",
+            },
+            {
+                name: "Apone",
+                personality: "Grizzled sergeant who keeps the squad in line. Practical, experienced, no tolerance for sloppy work.",
+            },
+            {
+                name: "Drake",
+                personality: "Heavy weapons partner who charges in first. Aggressive on deadlines, pushes pace, keeps momentum high.",
+            },
+        ],
+    },
+    {
+        id: "ghostbusters",
+        name: "Ghostbusters",
+        tagline: "Who ya gonna call?",
+        characters: [
+            {
+                name: "Venkman",
+                personality: "Wisecracking leader who keeps morale high. Skeptical, sarcastic, but ultimately gets things done with style.",
+            },
+            {
+                name: "Egon",
+                personality: "Brilliant scientist obsessed with data and precision. Dry wit, encyclopedic knowledge. Never guesses when he can measure.",
+            },
+            {
+                name: "Ray",
+                personality: "Enthusiastic engineer-scientist who gets genuinely excited about the work. Optimistic builder, loves a good challenge.",
+            },
+            {
+                name: "Winston",
+                personality: "Everyman voice of reason. Practical, grounded, asks the questions everyone else forgets. Reliable above all else.",
+            },
+            {
+                name: "Janine",
+                personality: "Sharp-tongued office manager who keeps everything organized. No-nonsense coordinator — nothing slips through the cracks.",
+            },
+            {
+                name: "Louis",
+                personality: "Eager accountant-turned-helper. Tries hard, brings unexpected value. Detail-oriented with numbers and logistics.",
+            },
+            {
+                name: "Dana",
+                personality: "Talented musician with strong convictions. Brings artistic perspective and high standards to quality.",
+            },
+            {
+                name: "Gozer",
+                personality: "Otherworldly force of nature. Brings raw, unstoppable energy. Approaches problems with cosmic-scale ambition.",
+            },
+        ],
+    },
+];
+/**
+ * Get a universe by ID.
+ */
+export function getUniverse(id) {
+    return UNIVERSES.find((u) => u.id === id);
+}
+/**
+ * Pick a random universe.
+ */
+export function randomUniverse() {
+    return UNIVERSES[Math.floor(Math.random() * UNIVERSES.length)];
+}
+/**
+ * Get the next unassigned character from a universe's pool.
+ * @param universeId The universe ID
+ * @param usedNames Character names already assigned to agents in this squad
+ * @returns The next available character, or undefined if all are taken
+ */
+export function nextCharacter(universeId, usedNames) {
+    const universe = getUniverse(universeId);
+    if (!universe)
+        return undefined;
+    const used = new Set(usedNames.map((n) => n.toLowerCase()));
+    return universe.characters.find((c) => !used.has(c.name.toLowerCase()));
+}
+//# sourceMappingURL=universes.js.map

package/dist/store/db.js

@@ -54,12 +54,31 @@ export function getDb() {
       completed_at DATETIME
     );
   `);
-    // Migration: add model column to squads (for existing databases)
-    try {
-        db.exec(`ALTER TABLE squads ADD COLUMN model TEXT`);
-    }
-    catch {
-        // Column already exists — ignore
+    // Migrations for existing databases
+    const migrations = [
+        `ALTER TABLE squads ADD COLUMN model TEXT`,
+        `ALTER TABLE squads ADD COLUMN universe TEXT`,
+        `CREATE TABLE IF NOT EXISTS squad_agents (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      squad_slug TEXT NOT NULL,
+      character_name TEXT NOT NULL,
+      role_title TEXT NOT NULL,
+      charter TEXT,
+      model_tier TEXT NOT NULL DEFAULT 'medium',
+      personality TEXT,
+      copilot_session_id TEXT,
+      status TEXT NOT NULL DEFAULT 'idle',
+      created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
+      UNIQUE(squad_slug, character_name)
+    )`,
+    ];
+    for (const migration of migrations) {
+        try {
+            db.exec(migration);
+        }
+        catch {
+            // Already applied — ignore
+        }
     }
     return db;
 }