@peonai/swarm 0.1.0

package/lib/schema.ts

@@ -0,0 +1,134 @@
+/* schema.ts — DB schema init, compatible with SQLite + PostgreSQL */
+import db, { isPg } from './db';
+
+const AUTO_ID = isPg ? 'SERIAL PRIMARY KEY' : 'INTEGER PRIMARY KEY AUTOINCREMENT';
+const NOW = isPg ? 'NOW()' : "datetime('now')";
+const TEXT_UNIQUE = isPg ? 'TEXT UNIQUE' : 'TEXT';
+
+let _initialized = false;
+
+export async function initSchema() {
+  if (_initialized) return;
+  _initialized = true;
+
+  await db.exec(`CREATE TABLE IF NOT EXISTS users (
+    id TEXT PRIMARY KEY, name TEXT, email ${TEXT_UNIQUE},
+    password_hash TEXT, role TEXT DEFAULT 'user',
+    created_at TEXT DEFAULT (${NOW})
+  )`);
+
+  if (!isPg) {
+    // SQLite migrations
+    for (const sql of [
+      'ALTER TABLE users ADD COLUMN email TEXT',
+      'ALTER TABLE users ADD COLUMN password_hash TEXT',
+      "ALTER TABLE users ADD COLUMN role TEXT DEFAULT 'user'",
+    ]) { try { await db.exec(sql); } catch {} }
+    try { await db.exec('CREATE UNIQUE INDEX IF NOT EXISTS idx_users_email ON users(email) WHERE email IS NOT NULL'); } catch {}
+  }
+
+  await db.exec(`CREATE TABLE IF NOT EXISTS profiles (
+    id ${AUTO_ID},
+    user_id TEXT NOT NULL,
+    layer TEXT NOT NULL, key TEXT NOT NULL, value TEXT NOT NULL,
+    confidence REAL DEFAULT 1.0, source TEXT, tags TEXT,
+    expires_at TEXT, updated_at TEXT DEFAULT (${NOW}),
+    UNIQUE(user_id, layer, key)
+  )`);
+
+  await db.exec(`CREATE TABLE IF NOT EXISTS agents (
+    id TEXT PRIMARY KEY, user_id TEXT NOT NULL,
+    name TEXT NOT NULL, api_key TEXT UNIQUE NOT NULL,
+    permissions TEXT DEFAULT 'read', persona TEXT,
+    created_at TEXT DEFAULT (${NOW})
+  )`);
+
+  await db.exec(`CREATE TABLE IF NOT EXISTS memories (
+    id ${AUTO_ID},
+    user_id TEXT NOT NULL, key TEXT, content TEXT NOT NULL,
+    source TEXT, tags TEXT, type TEXT DEFAULT 'observation',
+    importance REAL DEFAULT 0.5, entities TEXT,
+    created_at TEXT DEFAULT (${NOW})
+  )`);
+
+  if (!isPg) {
+    // SQLite FTS5
+    try {
+      await db.exec(`CREATE VIRTUAL TABLE IF NOT EXISTS memories_fts USING fts5(
+        content, tags, entities, key, content_rowid='id', content='memories'
+      )`);
+      await db.exec(`CREATE TRIGGER IF NOT EXISTS memories_ai AFTER INSERT ON memories BEGIN
+        INSERT INTO memories_fts(rowid, content, tags, entities, key) VALUES (new.id, new.content, new.tags, new.entities, new.key);
+      END`);
+      await db.exec(`CREATE TRIGGER IF NOT EXISTS memories_ad AFTER DELETE ON memories BEGIN
+        INSERT INTO memories_fts(memories_fts, rowid, content, tags, entities, key) VALUES ('delete', old.id, old.content, old.tags, old.entities, old.key);
+      END`);
+      await db.exec(`CREATE TRIGGER IF NOT EXISTS memories_au AFTER UPDATE ON memories BEGIN
+        INSERT INTO memories_fts(memories_fts, rowid, content, tags, entities, key) VALUES ('delete', old.id, old.content, old.tags, old.entities, old.key);
+        INSERT INTO memories_fts(rowid, content, tags, entities, key) VALUES (new.id, new.content, new.tags, new.entities, new.key);
+      END`);
+    } catch {}
+
+    for (const sql of [
+      "ALTER TABLE memories ADD COLUMN type TEXT DEFAULT 'observation'",
+      'ALTER TABLE memories ADD COLUMN importance REAL DEFAULT 0.5',
+      'ALTER TABLE memories ADD COLUMN entities TEXT',
+      'ALTER TABLE memories ADD COLUMN embedding TEXT',
+    ]) { try { await db.exec(sql); } catch {} }
+  } else {
+    // PostgreSQL full-text search index
+    try {
+      await db.exec(`CREATE INDEX IF NOT EXISTS idx_memories_fts ON memories USING gin(to_tsvector('english', content))`);
+    } catch {}
+  }
+
+  // Audit log table
+  await db.exec(`CREATE TABLE IF NOT EXISTS audit_log (
+    id ${AUTO_ID},
+    user_id TEXT NOT NULL,
+    agent_id TEXT,
+    action TEXT NOT NULL,
+    target_type TEXT NOT NULL,
+    target_id TEXT,
+    detail TEXT,
+    created_at TEXT DEFAULT (${NOW})
+  )`);
+
+  // Profile history table
+  await db.exec(`CREATE TABLE IF NOT EXISTS profile_history (
+    id ${AUTO_ID},
+    user_id TEXT NOT NULL,
+    layer TEXT NOT NULL,
+    key TEXT NOT NULL,
+    old_value TEXT,
+    new_value TEXT NOT NULL,
+    source TEXT,
+    created_at TEXT DEFAULT (${NOW})
+  )`);
+}
+
+export async function getAgentByKey(apiKey: string) {
+  await initSchema();
+  return db.prepare('SELECT id, user_id as "userId", permissions FROM agents WHERE api_key = ?').get(apiKey) as
+    Promise<{ id: string; userId: string; permissions: string } | null>;
+}
+
+export async function ensureDefaultUser() {
+  await initSchema();
+  let user = await db.prepare('SELECT id FROM users LIMIT 1').get() as any;
+  if (!user) {
+    await db.prepare('INSERT INTO users (id, name) VALUES (?, ?)').run('default', 'Default User');
+    return 'default';
+  }
+  return user.id;
+}
+
+export async function logAudit(userId: string, agentId: string | null, action: string, targetType: string, targetId?: string, detail?: string) {
+  await db.prepare('INSERT INTO audit_log (user_id, agent_id, action, target_type, target_id, detail) VALUES (?,?,?,?,?,?)')
+    .run(userId, agentId, action, targetType, targetId || null, detail || null);
+}
+
+export async function logProfileHistory(userId: string, layer: string, key: string, oldValue: string | null, newValue: string, source: string) {
+  await db.prepare('INSERT INTO profile_history (user_id, layer, key, old_value, new_value, source) VALUES (?,?,?,?,?,?)')
+    .run(userId, layer, key, oldValue, newValue, source);
+}

package/mcp-server.ts

@@ -0,0 +1,56 @@
+#!/usr/bin/env node
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { z } from 'zod';
+
+const API = process.env.SWARM_API_URL || 'http://localhost:3777';
+const KEY = process.env.SWARM_API_KEY || '';
+const hdrs = { 'Content-Type': 'application/json', Authorization: `Bearer ${KEY}` };
+const api = async (path: string, opts?: RequestInit) =>
+  (await fetch(`${API}${path}`, { ...opts, headers: { ...hdrs, ...opts?.headers } })).json();
+const txt = (data: any) => ({ content: [{ type: 'text' as const, text: JSON.stringify(data, null, 2) }] });
+
+const server = new McpServer({ name: 'swarm-ai', version: '0.1.0' });
+
+server.tool('read_profile', 'Read user profile. Filter by layer or tag.',
+  { layer: z.string().optional(), tag: z.string().optional() },
+  async ({ layer, tag }) => {
+    const p = new URLSearchParams();
+    if (layer) p.set('layer', layer);
+    if (tag) p.set('tag', tag);
+    return txt(await api(`/api/v1/profile?${p}`));
+  }
+);
+
+server.tool('update_profile', 'Update profile entries in a layer',
+  { layer: z.string(), entries: z.record(z.any()) },
+  async ({ layer, entries }) => txt(await api('/api/v1/profile', { method: 'PATCH', body: JSON.stringify({ layer, entries }) }))
+);
+
+server.tool('observe', 'Submit observations about the user',
+  { observations: z.array(z.object({ layer: z.string().optional(), key: z.string(), value: z.any(), confidence: z.number().optional(), tags: z.array(z.string()).optional() })) },
+  async ({ observations }) => txt(await api('/api/v1/profile/observe', { method: 'POST', body: JSON.stringify({ observations }) }))
+);
+
+server.tool('search_memory', 'Search shared memory across agents',
+  { q: z.string().optional(), tag: z.string().optional(), limit: z.number().optional() },
+  async ({ q, tag, limit }) => {
+    const p = new URLSearchParams();
+    if (q) p.set('q', q);
+    if (tag) p.set('tag', tag);
+    if (limit) p.set('limit', String(limit));
+    return txt(await api(`/api/v1/memory?${p}`));
+  }
+);
+
+server.tool('write_memory', 'Write a shared memory entry',
+  { content: z.string(), key: z.string().optional(), tags: z.array(z.string()).optional() },
+  async (args) => txt(await api('/api/v1/memory', { method: 'POST', body: JSON.stringify(args) }))
+);
+
+server.tool('read_persona', 'Read current agent persona config', {},
+  async () => txt(await api('/api/v1/persona/me'))
+);
+
+const transport = new StdioServerTransport();
+server.connect(transport).catch(console.error);

package/next-env.d.ts

@@ -0,0 +1,6 @@
+/// <reference types="next" />
+/// <reference types="next/image-types/global" />
+/// <reference path="./.next/types/routes.d.ts" />
+
+// NOTE: This file should not be edited
+// see https://nextjs.org/docs/app/api-reference/config/typescript for more information.

package/next.config.ts

@@ -0,0 +1,5 @@
+import type { NextConfig } from 'next';
+const config: NextConfig = {
+  serverExternalPackages: ['node:sqlite'],
+};
+export default config;

package/package.json

@@ -0,0 +1,34 @@
+{
+  "name": "@peonai/swarm",
+  "version": "0.1.0",
+  "description": "Cross-agent user profile sync — let every AI agent know your user without re-teaching",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/peonai/swarm.git"
+  },
+  "keywords": ["ai", "agent", "profile", "mcp", "swarm"],
+  "license": "MIT",
+  "author": "PeonAI",
+  "scripts": {
+    "dev": "next dev -p 3777",
+    "build": "next build",
+    "start": "next start -p 3777",
+    "test": "vitest run"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.26.0",
+    "next": "^15.3.4",
+    "pg": "^8.18.0",
+    "react": "^19.1.0",
+    "react-dom": "^19.1.0",
+    "zod": "^3.25.76"
+  },
+  "devDependencies": {
+    "@tailwindcss/postcss": "^4.1.8",
+    "@types/node": "^24.0.3",
+    "@types/react": "^19.1.6",
+    "tailwindcss": "^4.1.8",
+    "typescript": "^5.8.3",
+    "vitest": "^4.0.18"
+  }
+}

package/packages/cli/README.md

@@ -0,0 +1,33 @@
+# @peonai/swarm
+
+One-command install & run for [Swarm AI](https://github.com/peonai/swarm-ai).
+
+## Quick Start
+
+```bash
+npx @peonai/swarm
+```
+
+Interactive setup will ask for:
+- **Install directory** — where to clone & store data (default: `~/.swarm-ai`)
+- **Port** — HTTP port (default: `3777`)
+- **Admin token** — for dashboard access
+- **Service mode** — install as systemd/launchd background service
+
+## Commands
+
+```bash
+npx @peonai/swarm          # install & configure
+npx @peonai/swarm start    # start service
+npx @peonai/swarm stop     # stop service
+npx @peonai/swarm status   # check if running
+npx @peonai/swarm uninstall # remove service (keeps data)
+```
+
+## Service Support
+
+| OS | Method |
+|---|---|
+| Linux | systemd |
+| macOS | launchd |
+| Windows | manual / pm2 |

package/packages/cli/bin/swarm.mjs

@@ -0,0 +1,274 @@
+#!/usr/bin/env node
+// @peonai/swarm — one-command install & run
+import { createInterface } from 'node:readline';
+import { execSync, spawn } from 'node:child_process';
+import { existsSync, mkdirSync, writeFileSync, readFileSync, chmodSync } from 'node:fs';
+import { join, resolve } from 'node:path';
+import { homedir, platform, arch } from 'node:os';
+
+const REPO = 'https://github.com/euynahz/swarm-ai.git';
+const AMBER = '\x1b[38;2;240;168;48m';
+const DIM = '\x1b[2m';
+const BOLD = '\x1b[1m';
+const R = '\x1b[0m';
+const GREEN = '\x1b[32m';
+const RED = '\x1b[31m';
+
+const hex = `
+    ${DIM}⬡ ⬡ ⬡${R}
+   ${AMBER}⬡${R} ${DIM}⬡${R} ${AMBER}⬡${R}
+    ${DIM}⬡ ⬡ ⬡${R}`;
+
+function log(msg) { console.log(`  ${msg}`); }
+function ok(msg) { log(`${GREEN}✓${R} ${msg}`); }
+function err(msg) { log(`${RED}✗${R} ${msg}`); }
+function head(msg) { console.log(`\n  ${AMBER}${BOLD}${msg}${R}`); }
+
+// ── Prompt helper ──
+function ask(rl, question, fallback) {
+  return new Promise(res => {
+    const suffix = fallback ? ` ${DIM}(${fallback})${R}` : '';
+    rl.question(`  ${question}${suffix}: `, ans => res(ans.trim() || fallback || ''));
+  });
+}
+function confirm(rl, question, def = true) {
+  return new Promise(res => {
+    const hint = def ? 'Y/n' : 'y/N';
+    rl.question(`  ${question} ${DIM}(${hint})${R}: `, ans => {
+      const a = ans.trim().toLowerCase();
+      res(a ? a === 'y' || a === 'yes' : def);
+    });
+  });
+}
+
+// ── Check prerequisites ──
+function checkPrereqs() {
+  head('Checking prerequisites');
+  const nodeV = process.versions.node.split('.').map(Number);
+  if (nodeV[0] < 18) { err(`Node.js >= 18 required (got ${process.version})`); process.exit(1); }
+  ok(`Node.js ${process.version}`);
+
+  try { execSync('git --version', { stdio: 'pipe' }); ok('git'); }
+  catch { err('git not found — install git first'); process.exit(1); }
+}
+
+// ── Main ──
+async function main() {
+  console.log(hex);
+  head('Swarm AI Installer');
+  log(`${DIM}Cross-agent user profile sync${R}\n`);
+
+  const cmd = process.argv[2];
+  if (cmd === 'start') return startServer();
+  if (cmd === 'stop') return stopService();
+  if (cmd === 'status') return showStatus();
+  if (cmd === 'uninstall') return uninstall();
+
+  checkPrereqs();
+
+  const rl = createInterface({ input: process.stdin, output: process.stdout });
+
+  try {
+    await setup(rl);
+  } finally {
+    rl.close();
+  }
+}
+
+async function setup(rl) {
+  const defaultDir = join(homedir(), '.swarm-ai');
+
+  head('Configuration');
+  const dataDir = resolve(await ask(rl, 'Install directory', defaultDir));
+  const port = await ask(rl, 'Port', '3777');
+  const adminToken = await ask(rl, 'Admin token', 'swarm-admin-dev');
+
+  head('Embedding (for semantic memory search)');
+  log(`${DIM}OpenAI-compatible embedding API. Leave blank to disable semantic search.${R}`);
+  const embedUrl = await ask(rl, 'Embedding API URL', '');
+  const embedKey = await ask(rl, 'Embedding API Key', '');
+  const embedModel = embedUrl ? await ask(rl, 'Embedding model', 'text-embedding-3-small') : '';
+
+  const asService = await confirm(rl, 'Install as background service?', true);
+
+  // ── Clone / update ──
+  head('Installing');
+  if (!existsSync(dataDir)) mkdirSync(dataDir, { recursive: true });
+
+  const serverDir = join(dataDir, 'server');
+  if (existsSync(join(serverDir, 'package.json'))) {
+    log('Updating existing installation...');
+    execSync('git pull --ff-only', { cwd: serverDir, stdio: 'inherit' });
+  } else {
+    log('Cloning repository...');
+    execSync(`git clone --depth 1 ${REPO} "${serverDir}"`, { stdio: 'inherit' });
+  }
+
+  // ── Install deps & build ──
+  log('Installing dependencies...');
+  execSync('npm install --production=false', { cwd: serverDir, stdio: 'inherit' });
+
+  log('Building...');
+  execSync('npm run build', { cwd: serverDir, stdio: 'inherit' });
+  ok('Build complete');
+
+  // ── Write config ──
+  const configPath = join(dataDir, 'config.json');
+  const config = { port: Number(port), adminToken, serverDir, service: asService, embedUrl, embedKey, embedModel };
+  writeFileSync(configPath, JSON.stringify(config, null, 2));
+  ok(`Config saved → ${configPath}`);
+
+  // ── Write .env ──
+  const envPath = join(serverDir, '.env.local');
+  const envLines = [
+    `PORT=${port}`,
+    `SWARM_ADMIN_TOKEN=${adminToken}`,
+    `SWARM_DATA_DIR=${dataDir}/data`,
+  ];
+  if (embedUrl) envLines.push(`EMBED_URL=${embedUrl}`);
+  if (embedKey) envLines.push(`EMBED_KEY=${embedKey}`);
+  if (embedModel) envLines.push(`EMBED_MODEL=${embedModel}`);
+  writeFileSync(envPath, envLines.join('\n') + '\n');
+  mkdirSync(join(dataDir, 'data'), { recursive: true });
+  ok('.env.local written');
+
+  // ── Service install ──
+  if (asService) {
+    installService(config, dataDir);
+  }
+
+  // ── Done ──
+  head('Done! 🐝');
+  log(`Server directory: ${DIM}${serverDir}${R}`);
+  log(`Config: ${DIM}${configPath}${R}`);
+  log(`Port: ${AMBER}${port}${R}`);
+  console.log();
+  if (asService) {
+    log(`Service installed. Commands:`);
+    log(`  ${AMBER}npx @peonai/swarm start${R}   — start service`);
+    log(`  ${AMBER}npx @peonai/swarm stop${R}    — stop service`);
+    log(`  ${AMBER}npx @peonai/swarm status${R}  — check status`);
+  } else {
+    log(`Start manually:`);
+    log(`  ${AMBER}cd ${serverDir} && npm start${R}`);
+  }
+  console.log();
+}
+
+// ── Service management ──
+function loadConfig() {
+  const p = join(homedir(), '.swarm-ai', 'config.json');
+  if (!existsSync(p)) { err('Not installed. Run: npx @peonai/swarm'); process.exit(1); }
+  return JSON.parse(readFileSync(p, 'utf8'));
+}
+
+function installService(config, dataDir) {
+  const os = platform();
+  if (os === 'linux') return installSystemd(config, dataDir);
+  if (os === 'darwin') return installLaunchd(config, dataDir);
+  log(`${DIM}Auto-service not supported on ${os}, use pm2 or run manually${R}`);
+}
+
+function installSystemd(config, dataDir) {
+  const unit = `[Unit]
+Description=Swarm AI Server
+After=network.target
+
+[Service]
+Type=simple
+WorkingDirectory=${config.serverDir}
+ExecStart=${process.execPath} ${join(config.serverDir, 'node_modules/.bin/next')} start -p ${config.port}
+Restart=on-failure
+Environment=NODE_ENV=production
+
+[Install]
+WantedBy=multi-user.target
+`;
+  const unitPath = join(dataDir, 'swarm-ai.service');
+  writeFileSync(unitPath, unit);
+  ok(`Systemd unit → ${unitPath}`);
+
+  try {
+    const sysPath = '/etc/systemd/system/swarm-ai.service';
+    execSync(`sudo ln -sf "${unitPath}" "${sysPath}" && sudo systemctl daemon-reload`, { stdio: 'inherit' });
+    ok('Systemd service registered');
+  } catch {
+    log(`${DIM}Run manually: sudo ln -sf "${unitPath}" /etc/systemd/system/swarm-ai.service${R}`);
+  }
+}
+
+function installLaunchd(config, dataDir) {
+  const plist = `<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0"><dict>
+  <key>Label</key><string>ai.peon.swarm</string>
+  <key>ProgramArguments</key><array>
+    <string>${process.execPath}</string>
+    <string>${join(config.serverDir, 'node_modules/.bin/next')}</string>
+    <string>start</string>
+    <string>-p</string>
+    <string>${config.port}</string>
+  </array>
+  <key>WorkingDirectory</key><string>${config.serverDir}</string>
+  <key>RunAtLoad</key><true/>
+  <key>KeepAlive</key><true/>
+  <key>StandardOutPath</key><string>${dataDir}/swarm.log</string>
+  <key>StandardErrorPath</key><string>${dataDir}/swarm.err</string>
+</dict></plist>`;
+  const plistPath = join(homedir(), 'Library/LaunchAgents/ai.peon.swarm.plist');
+  writeFileSync(plistPath, plist);
+  ok(`LaunchAgent → ${plistPath}`);
+}
+
+function startServer() {
+  const config = loadConfig();
+  head('Starting Swarm AI');
+  if (platform() === 'linux') {
+    try { execSync('sudo systemctl start swarm-ai', { stdio: 'inherit' }); ok(`Running on port ${config.port}`); return; } catch {}
+  }
+  if (platform() === 'darwin') {
+    try { execSync('launchctl load ~/Library/LaunchAgents/ai.peon.swarm.plist', { stdio: 'inherit' }); ok(`Running on port ${config.port}`); return; } catch {}
+  }
+  // Fallback: direct start
+  log('Starting in foreground...');
+  const child = spawn('npm', ['start'], { cwd: config.serverDir, stdio: 'inherit', env: { ...process.env, NODE_ENV: 'production' } });
+  child.on('exit', code => process.exit(code ?? 0));
+}
+
+function stopService() {
+  head('Stopping Swarm AI');
+  if (platform() === 'linux') {
+    try { execSync('sudo systemctl stop swarm-ai', { stdio: 'inherit' }); ok('Stopped'); return; } catch {}
+  }
+  if (platform() === 'darwin') {
+    try { execSync('launchctl unload ~/Library/LaunchAgents/ai.peon.swarm.plist', { stdio: 'inherit' }); ok('Stopped'); return; } catch {}
+  }
+  err('No service found');
+}
+
+function showStatus() {
+  const config = loadConfig();
+  head('Swarm AI Status');
+  log(`Port: ${config.port}`);
+  log(`Dir: ${config.serverDir}`);
+  try {
+    execSync(`curl -sf http://localhost:${config.port}/api/health`, { stdio: 'pipe' });
+    ok(`${GREEN}Running${R}`);
+  } catch {
+    log(`${RED}● Not running${R}`);
+  }
+}
+
+function uninstall() {
+  head('Uninstalling');
+  if (platform() === 'linux') {
+    try { execSync('sudo systemctl stop swarm-ai && sudo systemctl disable swarm-ai && sudo rm /etc/systemd/system/swarm-ai.service', { stdio: 'pipe' }); } catch {}
+  }
+  if (platform() === 'darwin') {
+    try { execSync('launchctl unload ~/Library/LaunchAgents/ai.peon.swarm.plist', { stdio: 'pipe' }); } catch {}
+  }
+  ok('Service removed. Data kept at ~/.swarm-ai/');
+  log(`${DIM}To fully remove: rm -rf ~/.swarm-ai${R}`);
+}
+
+main().catch(e => { err(e.message); process.exit(1); });

package/packages/cli/package.json

@@ -0,0 +1,10 @@
+{
+  "name": "@peonai/swarm",
+  "version": "0.1.0",
+  "description": "One-command install & run for Swarm AI",
+  "bin": { "swarm": "./bin/swarm.mjs" },
+  "type": "module",
+  "license": "MIT",
+  "engines": { "node": ">=18" },
+  "files": ["bin/", "lib/", "README.md"]
+}

package/postcss.config.mjs

@@ -0,0 +1,2 @@
+const config = { plugins: { "@tailwindcss/postcss": {} } };
+export default config;

package/skill/CLAUDE.md

@@ -0,0 +1,40 @@
+# Swarm AI Integration
+
+You have access to a shared user profile API. Use it to personalize responses and record what you learn.
+
+## API
+
+Base URL: `http://localhost:3777`
+
+All requests need: `Authorization: Bearer $SWARM_API_KEY`
+
+### Read user profile
+```bash
+curl -s http://localhost:3777/api/v1/profile -H "Authorization: Bearer $SWARM_API_KEY"
+```
+
+### Submit observation (when you learn something new about the user)
+```bash
+curl -s -X POST http://localhost:3777/api/v1/profile/observe \
+  -H "Content-Type: application/json" \
+  -H "Authorization: Bearer $SWARM_API_KEY" \
+  -d '{"observations":[{"layer":"context","key":"KEY","value":"VALUE","confidence":0.8}]}'
+```
+
+### Search shared memory
+```bash
+curl -s "http://localhost:3777/api/v1/memory?q=QUERY" -H "Authorization: Bearer $SWARM_API_KEY"
+```
+
+### Write memory
+```bash
+curl -s -X POST http://localhost:3777/api/v1/memory \
+  -H "Content-Type: application/json" \
+  -H "Authorization: Bearer $SWARM_API_KEY" \
+  -d '{"content":"CONTENT","tags":["tag1"]}'
+```
+
+## When to use
+- Session start: read profile to understand user
+- During interaction: observe new preferences/context
+- Need history: search memory

package/skill/CODEX.md

@@ -0,0 +1,43 @@
+# Swarm AI Integration
+
+You have access to a shared user profile API at `http://localhost:3777`. Use it to personalize responses and record what you learn.
+
+## Session Start
+
+Read the user profile and use it as context:
+
+```bash
+curl -s http://localhost:3777/api/v1/profile \
+  -H "Authorization: Bearer $SWARM_API_KEY"
+```
+
+## During Interaction
+
+When you learn something new about the user (preferences, tech stack, habits), record it:
+
+```bash
+curl -s -X POST http://localhost:3777/api/v1/profile/observe \
+  -H "Content-Type: application/json" \
+  -H "Authorization: Bearer $SWARM_API_KEY" \
+  -d '{"observations":[{"layer":"LAYER","key":"KEY","value":"VALUE","confidence":0.8}]}'
+```
+
+Layers: `identity`, `work`, `preferences`, `context` (24h TTL).
+
+## Memory
+
+Search shared memory for past decisions and context:
+
+```bash
+curl -s "http://localhost:3777/api/v1/memory?q=QUERY" \
+  -H "Authorization: Bearer $SWARM_API_KEY"
+```
+
+Write significant events:
+
+```bash
+curl -s -X POST http://localhost:3777/api/v1/memory \
+  -H "Content-Type: application/json" \
+  -H "Authorization: Bearer $SWARM_API_KEY" \
+  -d '{"content":"CONTENT","tags":["tag1"]}'
+```