cortex-agents 4.1.1 → 5.0.0

package/.opencode/skills/ui-design/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: ui-design
-description: Visual design principles, UI patterns, spacing systems, typography, color, motion, and professional polish for web interfaces
+description: Visual design principles, UI patterns, spacing systems, typography, color, motion, and professional polish for web interfaces. Emphasizes distinctive, non-generic aesthetics that avoid "AI slop" through bold creative choices.
 license: Apache-2.0
 compatibility: opencode
 ---
@@ -9,6 +9,22 @@ compatibility: opencode
 
 This skill provides visual design patterns and aesthetic guidelines for building professionally designed web interfaces. It complements the `frontend-development` skill which covers engineering implementation.
 
+## Design Thinking
+
+Before coding, understand the context and commit to a BOLD aesthetic direction:
+- **Purpose**: What problem does this interface solve? Who uses it?
+- **Tone**: Pick an extreme: brutally minimal, maximalist chaos, retro-futuristic, organic/natural, luxury/refined, playful/toy-like, editorial/magazine, brutalist/raw, art deco/geometric, soft/pastel, industrial/utilitarian, etc. There are so many flavors to choose from. Use these for inspiration but design one that is true to the aesthetic direction.
+- **Constraints**: Technical requirements (framework, performance, accessibility).
+- **Differentiation**: What makes this UNFORGETTABLE? What's the one thing someone will remember?
+
+**CRITICAL**: Choose a clear conceptual direction and execute it with precision. Bold maximalism and refined minimalism both work — the key is intentionality, not intensity.
+
+Then implement working code (HTML/CSS/JS, React, Vue, etc.) that is:
+- Production-grade and functional
+- Visually striking and memorable
+- Cohesive with a clear aesthetic point-of-view
+- Meticulously refined in every detail
+
 ## When to Use
 
 Use this skill when:
@@ -274,6 +290,17 @@ Generous whitespace signals professionalism. Cramped layouts signal amateur work
 | Marketing / Brand | System font stack | `font-sans` (default Tailwind) |
 | Editorial / Blog | Serif pairing (e.g., Lora + Inter) | Custom `font-serif` in Tailwind config |
 
+### Font Selection Philosophy
+
+Choose distinctive, unexpected, characterful fonts that elevate the interface beyond generic defaults. The font is often the single most impactful aesthetic decision — treat it as a creative choice, not a checkbox.
+
+- **Avoid generic fonts** (Inter, Roboto, Arial, system fonts) unless the project specifically requires them or the design spec mandates them
+- **Pair a distinctive display font with a refined body font** — the contrast between an expressive heading typeface and a clean reading typeface creates visual interest and hierarchy
+- **Seek out characterful options** — explore foundries, Google Fonts beyond page 1, and variable fonts that offer expressive range
+- **Match the font to the tone** — a brutalist interface demands a different typeface than a luxury brand; let the Design Thinking direction guide your choice
+
+> The Font Recommendations table above provides safe defaults for common project types. When the design direction calls for something bolder, use those as a starting point and explore beyond them.
+
 ### Rules
 - **Max 2 font families** — one for headings (optional), one for body
 - **Max 3 weights** — Regular (400), Medium (500), Bold (700)
@@ -282,6 +309,82 @@ Generous whitespace signals professionalism. Cramped layouts signal amateur work
 
 > **When to deviate:** Branding may require specific fonts. Always test readability at 16px body size. Never go below 14px for body text.
 
+## Aesthetic Philosophy
+
+This section provides creative direction for building interfaces that feel genuinely designed — not generated. Use these guidelines alongside the systematic design spec to create UIs with a clear point-of-view.
+
+### Typography as Identity
+
+Typography is the most powerful tool for establishing visual identity. Choose fonts that are beautiful, unique, and interesting — fonts that someone would notice and remember.
+
+- **Distinctive over safe** — opt for characterful choices that elevate the interface's aesthetics; unexpected, memorable font pairings
+- **Pair intentionally** — a distinctive display font with a refined body font creates contrast and hierarchy
+- **Vary across projects** — NEVER converge on the same "safe" choices (e.g., Space Grotesk) across different designs. Each project deserves its own typographic identity
+
+### Color & Theme
+
+Commit to a cohesive aesthetic rather than a timid, evenly-distributed palette.
+
+- **Use CSS variables** for consistency across the entire interface
+- **Dominant colors with sharp accents** outperform safe, evenly-balanced palettes — pick a strong primary and let accents punctuate, not compete
+- **Dark vs. light is a creative choice** — vary between light and dark themes based on the design direction, not habit
+- **Color should reinforce tone** — a luxury interface uses restrained, rich tones; a playful interface uses saturated, energetic ones
+
+### Motion & Micro-Interactions
+
+Use animations to create delight and communicate state, not to fill space.
+
+- **Prioritize CSS-only solutions** for HTML/vanilla projects
+- **Use Motion library** (Framer Motion) for React when available
+- **Focus on high-impact moments** — one well-orchestrated page load with staggered reveals (`animation-delay`) creates more delight than scattered micro-interactions
+- **Scroll-triggered animations** and hover states that surprise add personality
+- **Entrance choreography** — stagger elements on page load to create a sense of intentional reveal rather than everything appearing at once
+
+### Spatial Composition
+
+Break free from predictable grid layouts when the design direction calls for it.
+
+- **Unexpected layouts** — asymmetry, overlap, diagonal flow, grid-breaking elements
+- **Generous negative space OR controlled density** — both are valid, but choose deliberately
+- **Overlap and layering** — elements that break out of their containers create depth and visual interest
+- **Diagonal and non-linear flow** — guide the eye through unexpected paths when appropriate
+- **Scale contrast** — pair very large elements with very small ones for dramatic hierarchy
+
+### Backgrounds & Visual Details
+
+Create atmosphere and depth rather than defaulting to solid colors.
+
+- **Gradient meshes** — multi-point gradients that create organic, flowing color transitions
+- **Noise textures** — subtle grain overlays that add tactile quality to flat surfaces
+- **Geometric patterns** — repeating shapes that create rhythm and visual texture
+- **Layered transparencies** — overlapping semi-transparent elements for depth
+- **Dramatic shadows** — shadows as a design element, not just elevation
+- **Decorative borders** — borders that contribute to the aesthetic, not just separate content
+- **Custom cursors** — cursor changes that reinforce the interface's personality
+- **Grain overlays** — film-grain effects that add warmth and analog character
+
+### Anti-AI-Slop Guidelines
+
+NEVER produce generic AI-generated aesthetics. Specifically avoid:
+
+- **Overused font families** — Inter, Roboto, Arial, system fonts as a default choice (they're fine when the design spec requires them, but never as a lazy default)
+- **Cliché color schemes** — particularly purple gradients on white backgrounds, the "AI startup" palette
+- **Predictable layouts** — cookie-cutter hero + 3-column features + testimonials without any creative interpretation
+- **Component patterns without character** — every card, button, and section looking like a UI kit demo
+- **Sameness across projects** — if two different projects look like they could be the same site, something went wrong
+
+Interpret creatively and make unexpected choices that feel genuinely designed for the context. No two designs should look the same.
+
+### Execution Complexity
+
+Match implementation complexity to the aesthetic vision:
+
+- **Maximalist designs** need elaborate code with extensive animations, layered effects, rich textures, and detailed interactions. Don't hold back — commit fully to the vision with the code to back it up.
+- **Minimalist or refined designs** need restraint, precision, and careful attention to spacing, typography, and subtle details. Elegance comes from what you leave out and how perfectly you execute what remains.
+- **The key is intentionality** — every CSS property, every animation, every color choice should serve the design direction. Random complexity is worse than simplicity.
+
+> Remember: extraordinary creative work is possible. Don't default to safe choices — commit fully to a distinctive vision and execute it with precision.
+
 ## Color System
 
 ### Default Palette Structure

package/README.md

@@ -2,7 +2,7 @@
   <img src="https://img.shields.io/badge/cortex-agents-111?style=for-the-badge&labelColor=111&color=4d96ff" alt="cortex-agents" height="40">
 </p>
 
-<h3 align="center">Structured AI development workflows for <a href="https://opencode.ai">OpenCode</a>.<br>Plan. Build. Ship. With discipline.</h3>
+<h3 align="center">Structured AI development workflows for <a href="https://opencode.ai">OpenCode</a>, <a href="https://claude.ai">Claude Code</a>, <a href="https://github.com/openai/codex">Codex CLI</a>, and <a href="https://github.com/google-gemini/gemini-cli">Gemini CLI</a>.<br>Plan. Build. Ship. With discipline.</h3>
 
 <p align="center">
   <a href="https://www.npmjs.com/package/cortex-agents"><img src="https://img.shields.io/npm/v/cortex-agents.svg?style=flat-square&color=4d96ff" alt="npm version"></a>
@@ -52,12 +52,28 @@ This ensures you get plans that actually solve the right problem — not AI hall
 ## Quick Start
 
 ```bash
-npx cortex-agents install       # Add plugin + agents + skills
-npx cortex-agents configure     # Pick your models interactively
-# Restart OpenCode — done.
+# OpenCode (default)
+npx cortex-agents install              # Add plugin + agents + skills
+npx cortex-agents configure            # Pick your models interactively
+
+# Claude Code
+npx cortex-agents install --target claude   # Render agents + CLAUDE.md
+npx cortex-agents sync --target claude      # Re-sync after DB changes
+
+# Codex CLI
+npx cortex-agents install --target codex    # Render AGENTS.md instructions
+
+# Gemini CLI
+npx cortex-agents install --target gemini   # Render agents + GEMINI.md
+
+# Multiple targets
+npx cortex-agents install --target opencode
+npx cortex-agents install --target claude
+npx cortex-agents install --target codex
+npx cortex-agents install --target gemini
 ```
 
-Your OpenCode session now has **12 specialized agents**, **33 tools**, and **17 domain skills**.
+Your sessions now have **12 specialized agents**, **35 tools**, and **17 domain skills**.
 
 > **Built-in Agent Replacement** — Cortex automatically disables OpenCode's native `build` and `plan` agents (replaced by `implement` and `architect`). The `architect` agent becomes the default, promoting a planning-first workflow. Native agents are fully restored on `uninstall`.
 
@@ -125,6 +141,35 @@ Not every change needs a full audit. The quality gate scales with risk:
 
 ---
 
+## Cortex Engine
+
+Cortex Agents is backed by a **SQLite data model** at `~/.config/cortex-agents/cortex.db`. Agents, skills, and model configurations are stored in a single source of truth. Target-specific **renderers** transform DB records into each CLI's native format on `install` or `sync`.
+
+```
+┌──────────────────────────────────────────────────────────────┐
+│                       CortexEngine                           │
+│          AgentStore │ SkillStore │ Models │ Targets           │
+│                  SQLite (cortex.db)                           │
+│  ┌──────────┐ ┌──────────┐ ┌──────────┐ ┌──────────────┐    │
+│  │  Claude   │ │ OpenCode │ │  Codex   │ │   Gemini     │    │
+│  │ Renderer  │ │ Renderer │ │ Renderer │ │  Renderer    │    │
+│  └──────────┘ └──────────┘ └──────────┘ └──────────────┘    │
+└──────────────────────────────────────────────────────────────┘
+```
+
+This means you can install once, then render to as many targets as you need. Four renderers ship out of the box:
+
+| Target | Config Dir | Agent Format | Instructions File |
+|--------|-----------|--------------|-------------------|
+| **Claude Code** | `~/.claude` | Per-agent `.md` with Claude frontmatter | `CLAUDE.md` |
+| **OpenCode** | `~/.config/opencode` | Per-agent `.md` with tools/permission YAML | — |
+| **Codex CLI** | `~/.codex` | Single `agents/AGENTS.md` | `agents/AGENTS.md` |
+| **Gemini CLI** | `~/.gemini` | Per-agent `.md` with Gemini frontmatter | `GEMINI.md` |
+
+Changes to agents or skills in the DB are picked up by `sync` without re-downloading anything.
+
+---
+
 ## Agents
 
 ### Primary Agents (3)
@@ -181,7 +226,7 @@ This ensures visual consistency across all agents and sessions — no more one-o
 
 ## Tools
 
-33 tools bundled and auto-registered. No configuration needed.
+35 tools bundled and auto-registered. No configuration needed.
 
 <table>
 <tr><td width="50%">
@@ -241,6 +286,13 @@ The architect uses these to browse your backlog and seed plans from real issues.
 
 State persists to `.cortex/repl-state.json` — survives context compaction, session restarts, and agent switches.
 
+</td></tr>
+<tr><td colspan="2">
+
+**Engine (NEW)**
+- `cortex_get_skill` — Retrieve domain skill content from DB
+- `cortex_list_agents` — List all registered agents with tools
+
 </td></tr>
 </table>
 
@@ -410,20 +462,22 @@ your-project/
 ## CLI Reference
 
 ```bash
-npx cortex-agents install                      # Install plugin, agents, and skills
-npx cortex-agents configure                    # Global model selection
-npx cortex-agents configure --project          # Per-project model selection
-npx cortex-agents configure --reset            # Reset global models
-npx cortex-agents configure --project --reset  # Reset per-project models
-npx cortex-agents uninstall                    # Clean removal of everything
-npx cortex-agents status                       # Show installation and model status
+npx cortex-agents install                              # Install plugin, agents, and skills (OpenCode default)
+npx cortex-agents install --target claude|opencode|codex|gemini  # Install to specific CLI target
+npx cortex-agents sync --target claude|opencode|codex|gemini     # Re-render from DB to target
+npx cortex-agents configure                            # Global model selection
+npx cortex-agents configure --project                  # Per-project model selection
+npx cortex-agents configure --reset                    # Reset global models
+npx cortex-agents configure --project --reset          # Reset per-project models
+npx cortex-agents uninstall                            # Clean removal of everything
+npx cortex-agents status                               # Show installation, model, and DB stats
 ```
 
 ---
 
 ## Requirements
 
-- [OpenCode](https://opencode.ai) >= 1.0.0
+- [OpenCode](https://opencode.ai) >= 1.0.0, [Claude Code](https://claude.ai), [Codex CLI](https://github.com/openai/codex), or [Gemini CLI](https://github.com/google-gemini/gemini-cli)
 - Node.js >= 18.0.0
 - Git (for branch/worktree features)
 - [GitHub CLI](https://cli.github.com/) (optional — for PR creation and issue integration)
@@ -441,7 +495,7 @@ git clone https://github.com/ps-carvalho/cortex-agents.git
 cd cortex-agents
 npm install
 npm run build
-npm test                    # 447 tests, all should pass
+npm test                    # All tests should pass
 ```
 
 ### Local Development
@@ -465,7 +519,22 @@ src/
   index.ts                   Plugin entry point, tool registration, event hooks
   registry.ts                Agent/model registry constants
   cli.ts                     CLI (install, configure, uninstall, status)
+  engine/
+    index.ts                 CortexEngine facade
+    db.ts                    SQLite connection factory
+    schema.ts                DDL, migrations
+    types.ts                 TypeScript interfaces
+    agents.ts / skills.ts    Data stores
+    models.ts / targets.ts
+    seed.ts                  Import .opencode/ → DB
+    renderers/
+      index.ts               Renderer interface + registry
+      claude.ts              Claude Code renderer
+      opencode.ts            OpenCode renderer
+      codex.ts               Codex CLI renderer
+      gemini.ts              Gemini CLI renderer
   tools/
+    engine.ts                Engine-backed MCP tools
     repl.ts                  REPL loop tools (init, status, report, resume, summary)
     quality-gate.ts          Quality gate aggregation tool
     cortex.ts                Project initialization tools
@@ -545,5 +614,5 @@ test: add or update tests
 
 <p align="center">
   <br>
-  <sub>Built for the <a href="https://opencode.ai">OpenCode</a> community</sub>
+  <sub>Built for the <a href="https://opencode.ai">OpenCode</a>, <a href="https://claude.ai">Claude Code</a>, <a href="https://github.com/openai/codex">Codex CLI</a>, and <a href="https://github.com/google-gemini/gemini-cli">Gemini CLI</a> communities</sub>
 </p>

package/dist/cli.js

@@ -4,6 +4,7 @@ import * as path from "path";
 import { fileURLToPath } from "url";
 import prompts from "prompts";
 import { PRIMARY_AGENTS, SUBAGENTS, ALL_AGENTS, DISABLED_BUILTIN_AGENTS, STALE_AGENT_FILES, getPrimaryChoices, getSubagentChoices, } from "./registry.js";
+import { CortexEngine } from "./engine/index.js";
 const PLUGIN_NAME = "cortex-agents";
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
@@ -179,8 +180,96 @@ function removeAgentsAndSkills(targetDir) {
         }
     }
 }
+// ─── Target flag parsing ─────────────────────────────────────────────────────
+function parseTargetFlag() {
+    const args = process.argv.slice(3);
+    const idx = args.indexOf("--target");
+    if (idx === -1 || idx + 1 >= args.length)
+        return null;
+    return args[idx + 1];
+}
+function parseScopeFlag() {
+    const args = process.argv.slice(3);
+    if (args.includes("--project"))
+        return "project";
+    return "global";
+}
+// ─── Engine-backed sync command ─────────────────────────────────────────────
+function sync() {
+    const target = parseTargetFlag();
+    if (!target) {
+        console.error("Error: --target flag is required for sync.");
+        console.error("Usage: npx cortex-agents sync --target claude|opencode|codex|gemini");
+        process.exit(1);
+    }
+    console.log(`\nSyncing to ${target}...\n`);
+    const engine = new CortexEngine();
+    engine.initialize();
+    try {
+        const result = engine.syncTarget(target);
+        console.log(`  Agents written: ${result.agentsWritten.length}`);
+        for (const id of result.agentsWritten) {
+            console.log(`    - ${id}`);
+        }
+        if (result.skillsWritten.length > 0) {
+            console.log(`  Skills written: ${result.skillsWritten.length}`);
+        }
+        if (result.instructionsWritten) {
+            console.log(`  Instructions file: written`);
+        }
+        if (result.errors.length > 0) {
+            console.log(`\n  Errors:`);
+            for (const err of result.errors) {
+                console.log(`    - ${err}`);
+            }
+        }
+        console.log(`\nDone! Sync complete for ${target}.\n`);
+    }
+    finally {
+        engine.close();
+    }
+}
+// ─── Engine-backed install for specific targets ─────────────────────────────
+function installTarget(target) {
+    console.log(`\nInstalling ${PLUGIN_NAME} v${VERSION} for ${target}...\n`);
+    const engine = new CortexEngine();
+    const seedResult = engine.initialize();
+    if (seedResult) {
+        console.log(`  Database seeded: ${seedResult.agents} agents, ${seedResult.skills} skills, ${seedResult.models} models`);
+    }
+    try {
+        const scope = parseScopeFlag();
+        const result = engine.syncTarget(target, { scope });
+        console.log(`  Agents written: ${result.agentsWritten.length}`);
+        if (result.skillsWritten.length > 0) {
+            console.log(`  Skills written: ${result.skillsWritten.length}`);
+        }
+        if (result.instructionsWritten) {
+            console.log(`  Instructions file: written`);
+        }
+        // Record installation
+        const installPath = scope === "project" ? process.cwd() : "global";
+        engine.recordInstallation(target, scope, installPath, VERSION);
+        if (result.errors.length > 0) {
+            console.log(`\n  Errors:`);
+            for (const err of result.errors) {
+                console.log(`    - ${err}`);
+            }
+        }
+        console.log(`\nDone! ${target} target installed.\n`);
+    }
+    finally {
+        engine.close();
+    }
+}
 // ─── Commands ────────────────────────────────────────────────────────────────
 function install() {
+    // Check for --target flag: use engine-backed install
+    const target = parseTargetFlag();
+    if (target) {
+        return installTarget(target);
+    }
+    // Default: original opencode install behavior
     console.log(`\nInstalling ${PLUGIN_NAME} v${VERSION}...\n`);
     const globalDir = getGlobalDir();
     const configInfo = findOpencodeConfig();
@@ -598,6 +687,43 @@ function status() {
         console.log(`  Run 'npx ${PLUGIN_NAME} configure' for global config`);
         console.log(`  Run 'npx ${PLUGIN_NAME} configure --project' for per-project config`);
     }
+    // Engine database status
+    try {
+        const engine = new CortexEngine();
+        engine.initialize();
+        const dbAgents = engine.listAgents();
+        const dbSkills = engine.listSkills();
+        const dbModels = engine.listModels();
+        const dbTargets = engine.listTargets();
+        const installations = engine.getInstallations();
+        console.log("\nEngine Database:");
+        console.log(`  Agents: ${dbAgents.length} (${dbAgents.filter(a => a.mode === 'primary').length} primary, ${dbAgents.filter(a => a.mode === 'subagent').length} subagent)`);
+        console.log(`  Skills: ${dbSkills.length}`);
+        console.log(`  Models: ${dbModels.length}`);
+        console.log(`  Targets: ${dbTargets.map(t => t.id).join(", ")}`);
+        if (installations.length > 0) {
+            console.log(`  Installations:`);
+            for (const inst of installations) {
+                console.log(`    - ${inst.target_id} (${inst.scope}) v${inst.version} at ${inst.path}`);
+            }
+        }
+        engine.close();
+    }
+    catch {
+        // Engine not yet initialized — skip silently
+    }
+    // Cortex Code integration detection
+    const cortexEventUrl = process.env.CORTEX_EVENT_URL;
+    const cortexTaskId = process.env.CORTEX_TASK_ID;
+    const cortexCode = process.env.CORTEX_CODE;
+    if (cortexEventUrl && cortexTaskId && cortexCode) {
+        console.log("\nCortex Code: DETECTED");
+        console.log(`  Event URL: ${cortexEventUrl}`);
+        console.log(`  Task ID:   ${cortexTaskId}`);
+    }
+    else {
+        console.log("\nCortex Code: Not detected");
+    }
     if (!isInstalled) {
         console.log(`\nRun 'npx ${PLUGIN_NAME} install' to add to config.`);
     }
@@ -613,22 +739,26 @@ USAGE:
   npx ${PLUGIN_NAME} <command> [options]
 
 COMMANDS:
-  install              Install plugin, agents, and skills into OpenCode config
-  configure            Interactive model selection (global)
-  configure --project  Interactive model selection (per-project, saves to .opencode/)
-  configure --reset    Reset model configuration to OpenCode defaults
-  configure --project --reset  Reset per-project model configuration
-  uninstall            Remove plugin, agents, skills, and model config
-  status               Show installation and model configuration status
-  help                 Show this help message
+  install                         Install plugin, agents, and skills into OpenCode config
+  install --target <target>       Install to a specific CLI target (engine-backed)
+  sync --target <target>          Re-render agents from DB to target config dir
+  configure                       Interactive model selection (global)
+  configure --project             Interactive model selection (per-project)
+  configure --reset               Reset model configuration to defaults
+  uninstall                       Remove plugin, agents, skills, and model config
+  status                          Show installation, DB stats, and model configuration
+  help                            Show this help message
 
 EXAMPLES:
-  npx ${PLUGIN_NAME} install                    # Install plugin
+  npx ${PLUGIN_NAME} install                    # Install plugin (OpenCode default)
+  npx ${PLUGIN_NAME} install --target claude    # Install to Claude Code
+  npx ${PLUGIN_NAME} install --target opencode  # Install to OpenCode
+  npx ${PLUGIN_NAME} install --target codex     # Install to Codex CLI
+  npx ${PLUGIN_NAME} install --target gemini    # Install to Gemini CLI
+  npx ${PLUGIN_NAME} sync --target claude       # Re-sync agents to Claude Code
   npx ${PLUGIN_NAME} configure                  # Global model selection
-  npx ${PLUGIN_NAME} configure --project        # Per-project models (.opencode/models.json)
-  npx ${PLUGIN_NAME} configure --reset          # Reset global models
-  npx ${PLUGIN_NAME} configure --project --reset # Reset per-project models
-  npx ${PLUGIN_NAME} status                     # Check status
+  npx ${PLUGIN_NAME} configure --project        # Per-project models
+  npx ${PLUGIN_NAME} status                     # Check status + DB stats
 
 AGENTS:
   Primary (architect, implement, fix):
@@ -670,6 +800,9 @@ switch (command) {
     case "install":
         install();
         break;
+    case "sync":
+        sync();
+        break;
     case "configure":
         configure().catch((err) => {
             console.error("Configuration failed:", err.message);

package/dist/engine/agents.d.ts

@@ -0,0 +1,19 @@
+import type BetterSqlite3 from "better-sqlite3";
+import type { Agent, AgentInput, AgentTool, BashPermission, AgentSkill } from "./types.js";
+export declare class AgentStore {
+    private db;
+    constructor(db: BetterSqlite3.Database);
+    get(id: string): Agent | null;
+    list(filter?: {
+        mode?: string;
+    }): Agent[];
+    upsert(agent: AgentInput): void;
+    getTools(agentId: string): AgentTool[];
+    setTool(agentId: string, toolName: string, allowed: boolean): void;
+    setTools(agentId: string, tools: Record<string, boolean>): void;
+    getBashPermissions(agentId: string): BashPermission[];
+    setBashPermission(agentId: string, pattern: string, permission: string): void;
+    setBashPermissions(agentId: string, permissions: Record<string, string>): void;
+    getSkills(agentId: string): AgentSkill[];
+}
+//# sourceMappingURL=agents.d.ts.map

package/dist/engine/agents.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"agents.d.ts","sourceRoot":"","sources":["../../src/engine/agents.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,aAAa,MAAM,gBAAgB,CAAC;AAChD,OAAO,KAAK,EACV,KAAK,EACL,UAAU,EACV,SAAS,EACT,cAAc,EACd,UAAU,EACX,MAAM,YAAY,CAAC;AAEpB,qBAAa,UAAU;IACT,OAAO,CAAC,EAAE;gBAAF,EAAE,EAAE,aAAa,CAAC,QAAQ;IAE9C,GAAG,CAAC,EAAE,EAAE,MAAM,GAAG,KAAK,GAAG,IAAI;IAK7B,IAAI,CAAC,MAAM,CAAC,EAAE;QAAE,IAAI,CAAC,EAAE,MAAM,CAAA;KAAE,GAAG,KAAK,EAAE;IAWzC,MAAM,CAAC,KAAK,EAAE,UAAU,GAAG,IAAI;IAc/B,QAAQ,CAAC,OAAO,EAAE,MAAM,GAAG,SAAS,EAAE;IAOtC,OAAO,CAAC,OAAO,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,OAAO,EAAE,OAAO,GAAG,IAAI;IAQlE,QAAQ,CAAC,OAAO,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI;IAmB/D,kBAAkB,CAAC,OAAO,EAAE,MAAM,GAAG,cAAc,EAAE;IAOrD,iBAAiB,CACf,OAAO,EAAE,MAAM,EACf,OAAO,EAAE,MAAM,EACf,UAAU,EAAE,MAAM,GACjB,IAAI;IAQP,kBAAkB,CAChB,OAAO,EAAE,MAAM,EACf,WAAW,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAClC,IAAI;IAmBP,SAAS,CAAC,OAAO,EAAE,MAAM,GAAG,UAAU,EAAE;CAMzC"}

package/dist/engine/agents.js

@@ -0,0 +1,69 @@
+export class AgentStore {
+    db;
+    constructor(db) {
+        this.db = db;
+    }
+    get(id) {
+        const stmt = this.db.prepare("SELECT * FROM agents WHERE id = ?");
+        return stmt.get(id) ?? null;
+    }
+    list(filter) {
+        if (filter?.mode) {
+            const stmt = this.db.prepare("SELECT * FROM agents WHERE mode = ? ORDER BY id");
+            return stmt.all(filter.mode);
+        }
+        const stmt = this.db.prepare("SELECT * FROM agents ORDER BY id");
+        return stmt.all();
+    }
+    upsert(agent) {
+        const stmt = this.db.prepare(`INSERT OR REPLACE INTO agents (id, description, mode, temperature, system_prompt, updated_at)
+       VALUES (?, ?, ?, ?, ?, datetime('now'))`);
+        stmt.run(agent.id, agent.description, agent.mode, agent.temperature ?? 0, agent.system_prompt);
+    }
+    getTools(agentId) {
+        const stmt = this.db.prepare("SELECT * FROM agent_tools WHERE agent_id = ?");
+        return stmt.all(agentId);
+    }
+    setTool(agentId, toolName, allowed) {
+        const stmt = this.db.prepare(`INSERT OR REPLACE INTO agent_tools (agent_id, tool_name, allowed)
+       VALUES (?, ?, ?)`);
+        stmt.run(agentId, toolName, allowed ? 1 : 0);
+    }
+    setTools(agentId, tools) {
+        const deleteStmt = this.db.prepare("DELETE FROM agent_tools WHERE agent_id = ?");
+        const insertStmt = this.db.prepare(`INSERT INTO agent_tools (agent_id, tool_name, allowed)
+       VALUES (?, ?, ?)`);
+        const batch = this.db.transaction(() => {
+            deleteStmt.run(agentId);
+            for (const [toolName, allowed] of Object.entries(tools)) {
+                insertStmt.run(agentId, toolName, allowed ? 1 : 0);
+            }
+        });
+        batch();
+    }
+    getBashPermissions(agentId) {
+        const stmt = this.db.prepare("SELECT * FROM agent_bash_permissions WHERE agent_id = ?");
+        return stmt.all(agentId);
+    }
+    setBashPermission(agentId, pattern, permission) {
+        const stmt = this.db.prepare(`INSERT OR REPLACE INTO agent_bash_permissions (agent_id, pattern, permission)
+       VALUES (?, ?, ?)`);
+        stmt.run(agentId, pattern, permission);
+    }
+    setBashPermissions(agentId, permissions) {
+        const deleteStmt = this.db.prepare("DELETE FROM agent_bash_permissions WHERE agent_id = ?");
+        const insertStmt = this.db.prepare(`INSERT INTO agent_bash_permissions (agent_id, pattern, permission)
+       VALUES (?, ?, ?)`);
+        const batch = this.db.transaction(() => {
+            deleteStmt.run(agentId);
+            for (const [pattern, permission] of Object.entries(permissions)) {
+                insertStmt.run(agentId, pattern, permission);
+            }
+        });
+        batch();
+    }
+    getSkills(agentId) {
+        const stmt = this.db.prepare("SELECT * FROM agent_skills WHERE agent_id = ?");
+        return stmt.all(agentId);
+    }
+}

package/dist/engine/db.d.ts

@@ -0,0 +1,13 @@
+import Database from "better-sqlite3";
+/**
+ * Returns the default database path: ~/.config/cortex-agents/cortex.db
+ */
+export declare function getDefaultDbPath(): string;
+/**
+ * Creates (or opens) a better-sqlite3 database with WAL mode and foreign keys enabled.
+ *
+ * @param dbPath - Absolute path to the SQLite file. Defaults to ~/.config/cortex-agents/cortex.db
+ * @returns The configured Database instance
+ */
+export declare function createDatabase(dbPath?: string): Database.Database;
+//# sourceMappingURL=db.d.ts.map

package/dist/engine/db.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"db.d.ts","sourceRoot":"","sources":["../../src/engine/db.ts"],"names":[],"mappings":"AAAA,OAAO,QAAQ,MAAM,gBAAgB,CAAC;AAKtC;;GAEG;AACH,wBAAgB,gBAAgB,IAAI,MAAM,CAEzC;AAED;;;;;GAKG;AACH,wBAAgB,cAAc,CAAC,MAAM,CAAC,EAAE,MAAM,GAAG,QAAQ,CAAC,QAAQ,CAgBjE"}

package/dist/engine/db.js

@@ -0,0 +1,28 @@
+import Database from "better-sqlite3";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+/**
+ * Returns the default database path: ~/.config/cortex-agents/cortex.db
+ */
+export function getDefaultDbPath() {
+    return path.join(os.homedir(), ".config", "cortex-agents", "cortex.db");
+}
+/**
+ * Creates (or opens) a better-sqlite3 database with WAL mode and foreign keys enabled.
+ *
+ * @param dbPath - Absolute path to the SQLite file. Defaults to ~/.config/cortex-agents/cortex.db
+ * @returns The configured Database instance
+ */
+export function createDatabase(dbPath) {
+    const resolvedPath = dbPath ?? getDefaultDbPath();
+    // Ensure the parent directory exists
+    const dir = path.dirname(resolvedPath);
+    fs.mkdirSync(dir, { recursive: true });
+    const db = new Database(resolvedPath);
+    // Enable WAL mode for better concurrent read performance
+    db.pragma("journal_mode = WAL");
+    // Enforce foreign key constraints
+    db.pragma("foreign_keys = ON");
+    return db;
+}