pgserve 2.1.3 → 2.2.1

package/src/upgrade/index.js

@@ -0,0 +1,65 @@
+/**
+ * autopg upgrade — idempotent migration orchestrator.
+ *
+ * Runs 6 steps in order, each safe to re-run any number of times:
+ *   1. port-reconcile    — ensure pgserve listens on canonical port (8432)
+ *   2. binary-cache-flush — verify binary version matches PINNED_PG_VERSION
+ *   3. plpgsql-resolve   — DROP+CREATE plpgsql per DB to refresh .so path
+ *   4. env-refresh       — regenerate ~/.autopg/<app>.env URLs
+ *   5. consumer-signal   — touch ~/.autopg/state/upgrade.signal
+ *   6. health-validate   — pg_isready + per-DB plpgsql smoke test
+ *
+ * Patches the upgrade-path hole left by autopg-v22 partial roll-out.
+ * See: .genie/wishes/autopg-upgrade-command/WISH.md
+ */
+
+import { runStep } from './runner.js';
+import * as portReconcile from './steps/port-reconcile.js';
+import * as binaryCacheFlush from './steps/binary-cache-flush.js';
+import * as plpgsqlResolve from './steps/plpgsql-resolve.js';
+import * as envRefresh from './steps/env-refresh.js';
+import * as consumerSignal from './steps/consumer-signal.js';
+import * as healthValidate from './steps/health-validate.js';
+
+export const STEPS = [
+  { name: 'port-reconcile', impl: portReconcile },
+  { name: 'binary-cache-flush', impl: binaryCacheFlush },
+  { name: 'plpgsql-resolve', impl: plpgsqlResolve },
+  { name: 'env-refresh', impl: envRefresh },
+  { name: 'consumer-signal', impl: consumerSignal },
+  { name: 'health-validate', impl: healthValidate },
+];
+
+export async function upgrade(options = {}) {
+  const { quiet = false, dryRun = false, skipSteps = [] } = options;
+  const log = (msg) => { if (!quiet) process.stderr.write(`${msg}\n`); };
+  const warn = (msg) => process.stderr.write(`${msg}\n`);
+
+  log(`autopg upgrade starting (dryRun=${dryRun}, quiet=${quiet})`);
+
+  const results = [];
+  for (const step of STEPS) {
+    if (skipSteps.includes(step.name)) {
+      log(`[${step.name}] SKIP (excluded by --skip-steps)`);
+      results.push({ name: step.name, status: 'SKIP', detail: 'excluded' });
+      continue;
+    }
+    try {
+      const result = await runStep(step.name, step.impl, { dryRun, log, warn });
+      results.push(result);
+    } catch (err) {
+      warn(`[${step.name}] FAIL: ${err.message}`);
+      results.push({ name: step.name, status: 'FAIL', detail: err.message });
+    }
+  }
+
+  const failed = results.filter((r) => r.status === 'FAIL');
+  const summary = `autopg upgrade complete: ${results.length - failed.length}/${results.length} steps OK`;
+  log(summary);
+  if (failed.length > 0) {
+    warn(`Failed steps: ${failed.map((r) => r.name).join(', ')}`);
+    warn('Re-run `autopg upgrade` after addressing the above.');
+    return { ok: false, results, summary };
+  }
+  return { ok: true, results, summary };
+}

package/src/upgrade/runner.js

@@ -0,0 +1,23 @@
+/**
+ * Step runner — wraps each step with consistent logging + error capture.
+ *
+ * A step module exports `{ name, plan(ctx), execute(ctx) }`:
+ *   - plan(ctx)    → string describing what would happen (dry-run output)
+ *   - execute(ctx) → { status: 'OK'|'SKIP'|'FAIL', detail: string }
+ */
+
+export async function runStep(name, stepImpl, { dryRun, log, warn }) {
+  if (typeof stepImpl.plan !== 'function' || typeof stepImpl.execute !== 'function') {
+    throw new Error(`step ${name} missing plan() or execute()`);
+  }
+  if (dryRun) {
+    const planned = await stepImpl.plan({ log, warn });
+    log(`[${name}] DRY-RUN: ${planned}`);
+    return { name, status: 'DRY-RUN', detail: planned };
+  }
+  const result = await stepImpl.execute({ log, warn });
+  const status = result.status || 'OK';
+  const detail = result.detail || '';
+  log(`[${name}] ${status}: ${detail}`);
+  return { name, status, detail };
+}

package/src/upgrade/steps/binary-cache-flush.js

@@ -0,0 +1,67 @@
+/**
+ * Step 2 — Binary cache flush against PINNED_PG_VERSION.
+ * Re-downloads if version marker missing or mismatch. Idempotent.
+ */
+
+import fs from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+export const name = 'binary-cache-flush';
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+
+function getAutopgRoot() {
+  return process.env.AUTOPG_CONFIG_DIR || process.env.PGSERVE_CONFIG_DIR || `${process.env.HOME}/.autopg`;
+}
+
+function getBinaryCacheDir() {
+  return path.join(getAutopgRoot(), 'bin', `${process.platform}-${process.arch}`);
+}
+
+function getPinnedVersion() {
+  try {
+    const pkg = JSON.parse(fs.readFileSync(path.join(__dirname, '..', '..', '..', 'package.json'), 'utf8'));
+    if (pkg.autopg && pkg.autopg.pinnedPgVersion) return pkg.autopg.pinnedPgVersion;
+  } catch { /* fall through */ }
+  return process.env.AUTOPG_PINNED_PG_VERSION || '18.3';
+}
+
+function readVersionMarker(cacheDir) {
+  try { return fs.readFileSync(path.join(cacheDir, '.version'), 'utf8').trim(); } catch { return null; }
+}
+
+export async function plan() {
+  const cacheDir = getBinaryCacheDir();
+  const pinned = getPinnedVersion();
+  const marker = readVersionMarker(cacheDir);
+  if (!fs.existsSync(path.join(cacheDir, 'bin', 'postgres'))) {
+    return `binary missing at ${cacheDir} — would trigger download for PG ${pinned}`;
+  }
+  if (marker !== pinned) return `version drift (cached=${marker || 'unknown'}, pinned=${pinned}) — would re-download`;
+  return `binary present and matches pinned ${pinned}, no action needed`;
+}
+
+export async function execute({ log, warn }) {
+  const cacheDir = getBinaryCacheDir();
+  const pinned = getPinnedVersion();
+  const marker = readVersionMarker(cacheDir);
+  const binaryExists = fs.existsSync(path.join(cacheDir, 'bin', 'postgres'));
+
+  if (binaryExists && marker === pinned) return { status: 'SKIP', detail: `binary OK (PG ${pinned})` };
+
+  let downloadFn;
+  try {
+    const postgres = await import('../../postgres.js');
+    downloadFn = postgres.ensureBinary || postgres.downloadBinary || postgres.installBinary;
+  } catch { /* postgres module not loadable here */ }
+
+  if (!downloadFn) {
+    warn(`binary needs refresh (pinned=${pinned}, cached=${marker || 'missing'}) but autopg postgres module not exposing download API`);
+    warn(`operator action: rerun \`bun install -g @automagik/autopg@latest\``);
+    return { status: 'FAIL', detail: 'binary refresh needs autopg npm reinstall' };
+  }
+  log(`re-downloading PG ${pinned} into ${cacheDir}`);
+  await downloadFn({ version: pinned, targetDir: cacheDir });
+  fs.writeFileSync(path.join(cacheDir, '.version'), pinned, { mode: 0o644 });
+  return { status: 'OK', detail: `binary refreshed to PG ${pinned}` };
+}

package/src/upgrade/steps/consumer-signal.js

@@ -0,0 +1,40 @@
+/**
+ * Step 5 — Consumer reconnect signal. Touches ~/.autopg/state/upgrade.signal
+ * with epoch + autopg version. Consumers (omni-api, genie-serve) opt-in via fs.watch.
+ */
+
+import fs from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+export const name = 'consumer-signal';
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+
+function getAutopgRoot() {
+  return process.env.AUTOPG_CONFIG_DIR || process.env.PGSERVE_CONFIG_DIR || `${process.env.HOME}/.autopg`;
+}
+
+function getAutopgVersion() {
+  try {
+    const pkg = JSON.parse(fs.readFileSync(path.join(__dirname, '..', '..', '..', 'package.json'), 'utf8'));
+    return pkg.version || 'unknown';
+  } catch { return 'unknown'; }
+}
+
+export async function plan() {
+  return `would write upgrade signal at ${path.join(getAutopgRoot(), 'state', 'upgrade.signal')}`;
+}
+
+export async function execute() {
+  const signalDir = path.join(getAutopgRoot(), 'state');
+  fs.mkdirSync(signalDir, { recursive: true });
+  const payload = {
+    timestamp: new Date().toISOString(),
+    epoch_ms: Date.now(),
+    autopg_version: getAutopgVersion(),
+    canonical_port: 8432,
+  };
+  const signalPath = path.join(signalDir, 'upgrade.signal');
+  fs.writeFileSync(signalPath, `${JSON.stringify(payload, null, 2)}\n`, { mode: 0o644 });
+  return { status: 'OK', detail: `signal written at ${signalPath}` };
+}

package/src/upgrade/steps/env-refresh.js

@@ -0,0 +1,89 @@
+/**
+ * Step 4 — App env file refresh. Regenerates ~/.autopg/<name>.env with
+ * canonical port. Verifies SCRAM cred works; warns if rotation needed.
+ */
+
+import fs from 'node:fs';
+import path from 'node:path';
+import { execSync } from 'node:child_process';
+
+export const name = 'env-refresh';
+const CANONICAL_PORT = 8432;
+
+function getAutopgRoot() {
+  return process.env.AUTOPG_CONFIG_DIR || process.env.PGSERVE_CONFIG_DIR || `${process.env.HOME}/.autopg`;
+}
+
+function listAppEnvFiles() {
+  const root = getAutopgRoot();
+  if (!fs.existsSync(root)) return [];
+  return fs.readdirSync(root)
+    .filter((f) => f.endsWith('.env') && !f.startsWith('.'))
+    .map((f) => path.join(root, f));
+}
+
+function parseEnv(content) {
+  const out = {};
+  for (const line of content.split('\n')) {
+    const m = line.match(/^([A-Z_][A-Z0-9_]*)=(.*)$/);
+    if (m) out[m[1]] = m[2].replace(/^"(.*)"$/, '$1');
+  }
+  return out;
+}
+
+function buildUrl({ user, password, port, db }) {
+  const enc = (s) => encodeURIComponent(s);
+  return `postgresql://${enc(user)}:${enc(password)}@127.0.0.1:${port}/${db}`;
+}
+
+function tryConnect(url) {
+  try {
+    execSync(`psql ${JSON.stringify(url)} -At -c "SELECT 1"`, { stdio: 'pipe', env: process.env });
+    return true;
+  } catch { return false; }
+}
+
+export async function plan() {
+  const files = listAppEnvFiles();
+  if (files.length === 0) return 'no app .env files found in autopg root';
+  return `would verify+rewrite ${files.length} env file(s): ${files.map((f) => path.basename(f)).join(', ')}`;
+}
+
+export async function execute({ warn }) {
+  const files = listAppEnvFiles();
+  if (files.length === 0) return { status: 'SKIP', detail: 'no .env files' };
+
+  let updated = 0, valid = 0;
+  for (const file of files) {
+    try {
+      const content = fs.readFileSync(file, 'utf8');
+      const env = parseEnv(content);
+      const url = env.DATABASE_URL || env.PG_URL || env.POSTGRES_URL;
+      if (!url) {
+        warn(`[env-refresh] ${path.basename(file)}: no DATABASE_URL key`);
+        continue;
+      }
+      const parsed = new URL(url);
+      const newUrl = buildUrl({
+        user: decodeURIComponent(parsed.username),
+        password: decodeURIComponent(parsed.password),
+        port: CANONICAL_PORT,
+        db: parsed.pathname.replace(/^\//, ''),
+      });
+
+      if (tryConnect(newUrl)) {
+        valid++;
+        if (newUrl !== url) {
+          const newContent = content.replace(/^(DATABASE_URL|PG_URL|POSTGRES_URL)=.*/m, `$1=${newUrl}`);
+          fs.writeFileSync(file, newContent, { mode: 0o600 });
+          updated++;
+        }
+      } else {
+        warn(`[env-refresh] ${path.basename(file)}: SCRAM cred fails — rotate via \`autopg rotate <app>\``);
+      }
+    } catch (err) {
+      warn(`[env-refresh] ${path.basename(file)} failed: ${err.message}`);
+    }
+  }
+  return { status: 'OK', detail: `validated ${valid}/${files.length}, rewrote ${updated}` };
+}

package/src/upgrade/steps/health-validate.js

@@ -0,0 +1,53 @@
+/**
+ * Step 6 — Health validation. pg_isready + per-DB plpgsql smoke test.
+ */
+
+import { execSync } from 'node:child_process';
+
+export const name = 'health-validate';
+const CANONICAL_PORT = 8432;
+const SYSTEM_DBS = new Set(['template0', 'template1']);
+
+function pgIsReady() {
+  try { execSync(`pg_isready -h 127.0.0.1 -p ${CANONICAL_PORT}`, { stdio: 'pipe' }); return true; }
+  catch { return false; }
+}
+
+function listAllDbs() {
+  const env = { ...process.env, PGPASSWORD: process.env.PGPASSWORD || 'postgres' };
+  const out = execSync(
+    `psql -h 127.0.0.1 -p ${CANONICAL_PORT} -U postgres -At -c "SELECT datname FROM pg_database WHERE NOT datistemplate"`,
+    { env, stdio: ['ignore', 'pipe', 'pipe'] },
+  ).toString().trim();
+  return out ? out.split('\n').filter(Boolean) : [];
+}
+
+function plpgsqlSmoke(db) {
+  try {
+    const env = { ...process.env, PGPASSWORD: process.env.PGPASSWORD || 'postgres' };
+    execSync(
+      `psql -h 127.0.0.1 -p ${CANONICAL_PORT} -U postgres -d ${db} -At -c "DO \\$\\$ BEGIN RAISE NOTICE 'ok'; END; \\$\\$"`,
+      { env, stdio: 'pipe' },
+    );
+    return true;
+  } catch { return false; }
+}
+
+export async function plan() {
+  return `would check pg_isready on :${CANONICAL_PORT} + plpgsql smoke test in each user DB`;
+}
+
+export async function execute({ warn }) {
+  if (!pgIsReady()) return { status: 'FAIL', detail: `pg_isready failed on port ${CANONICAL_PORT}` };
+  let dbs;
+  try { dbs = listAllDbs(); } catch (err) { return { status: 'FAIL', detail: `cannot list DBs: ${err.message}` }; }
+
+  let pass = 0, fail = 0;
+  for (const db of dbs) {
+    if (SYSTEM_DBS.has(db)) continue;
+    if (plpgsqlSmoke(db)) pass++;
+    else { fail++; warn(`[health-validate] plpgsql smoke FAIL in ${db}`); }
+  }
+  if (fail > 0) return { status: 'FAIL', detail: `${pass}/${pass + fail} DBs healthy; ${fail} failure(s)` };
+  return { status: 'OK', detail: `pg_isready OK, plpgsql healthy in ${pass}/${pass} DBs` };
+}

package/src/upgrade/steps/plpgsql-resolve.js

@@ -0,0 +1,66 @@
+/**
+ * Step 3 — plpgsql extension re-resolve.
+ * DROP+CREATE plpgsql per user DB to refresh `.so` path against current $libdir.
+ * Skips DBs with user-owned plpgsql functions (CASCADE would drop them).
+ */
+
+import { execSync } from 'node:child_process';
+
+export const name = 'plpgsql-resolve';
+const CANONICAL_PORT = 8432;
+const SYSTEM_DBS = new Set(['postgres', 'template0', 'template1']);
+
+function pgQuery({ db, sql, captureStdout = false }) {
+  const env = { ...process.env, PGPASSWORD: process.env.PGPASSWORD || 'postgres' };
+  const cmd = `psql -h 127.0.0.1 -p ${CANONICAL_PORT} -U postgres -d ${db} -At -c ${JSON.stringify(sql)}`;
+  return captureStdout
+    ? execSync(cmd, { env, stdio: ['ignore', 'pipe', 'pipe'] }).toString().trim()
+    : execSync(cmd, { env, stdio: 'pipe' });
+}
+
+function listUserDbs() {
+  const out = pgQuery({
+    db: 'postgres',
+    sql: "SELECT datname FROM pg_database WHERE NOT datistemplate AND datname != 'postgres' ORDER BY datname",
+    captureStdout: true,
+  });
+  return out ? out.split('\n').filter(Boolean) : [];
+}
+
+function hasUserOwnedPlpgsqlFunctions(db) {
+  const out = pgQuery({
+    db,
+    sql: "SELECT count(*) FROM pg_proc p JOIN pg_language l ON p.prolang = l.oid WHERE l.lanname = 'plpgsql' AND p.proowner != 10",
+    captureStdout: true,
+  });
+  return parseInt(out, 10) > 0;
+}
+
+export async function plan() {
+  let dbs;
+  try { dbs = listUserDbs(); } catch (err) { return `cannot enumerate DBs: ${err.message}`; }
+  return `would DROP+CREATE plpgsql in ${dbs.length} user DB(s): ${dbs.join(', ')}`;
+}
+
+export async function execute({ warn }) {
+  let dbs;
+  try { dbs = listUserDbs(); } catch (err) { return { status: 'FAIL', detail: `cannot enumerate DBs: ${err.message}` }; }
+  if (dbs.length === 0) return { status: 'SKIP', detail: 'no user DBs to refresh' };
+
+  let refreshed = 0, skipped = 0;
+  for (const db of dbs) {
+    if (SYSTEM_DBS.has(db)) { skipped++; continue; }
+    try {
+      if (hasUserOwnedPlpgsqlFunctions(db)) {
+        warn(`[plpgsql-resolve] skip ${db}: user-owned plpgsql functions present (DROP CASCADE would lose them)`);
+        skipped++; continue;
+      }
+      pgQuery({ db, sql: 'DROP EXTENSION IF EXISTS plpgsql CASCADE; CREATE EXTENSION plpgsql' });
+      refreshed++;
+    } catch (err) {
+      warn(`[plpgsql-resolve] ${db} failed: ${err.message}`);
+      skipped++;
+    }
+  }
+  return { status: 'OK', detail: `refreshed ${refreshed} DB(s), skipped ${skipped}` };
+}

package/src/upgrade/steps/port-reconcile.js

@@ -0,0 +1,52 @@
+/**
+ * Step 1 — Port reconciliation. Ensures pgserve listens on canonical 8432.
+ * If running on a different port, stop and relaunch on 8432. Idempotent.
+ */
+
+import { execSync } from 'node:child_process';
+import fs from 'node:fs';
+import path from 'node:path';
+
+export const name = 'port-reconcile';
+const CANONICAL_PORT = 8432;
+
+function readPostmasterPid(dataDir) {
+  try {
+    const content = fs.readFileSync(path.join(dataDir, 'postmaster.pid'), 'utf8');
+    const lines = content.trim().split('\n');
+    return { pid: parseInt(lines[0], 10), port: parseInt(lines[3], 10) };
+  } catch {
+    return null;
+  }
+}
+
+function getDataDir() {
+  return process.env.PGSERVE_DATA || `${process.env.HOME}/.pgserve/data`;
+}
+
+export async function plan() {
+  const info = readPostmasterPid(getDataDir());
+  if (!info) return 'no running pgserve detected — nothing to reconcile';
+  if (info.port === CANONICAL_PORT) return `already on port ${CANONICAL_PORT}, no action needed`;
+  return `would stop pgserve PID ${info.pid} (port ${info.port}) and relaunch on ${CANONICAL_PORT}`;
+}
+
+export async function execute({ log, warn }) {
+  const info = readPostmasterPid(getDataDir());
+  if (!info) return { status: 'SKIP', detail: 'no running pgserve' };
+  if (info.port === CANONICAL_PORT) return { status: 'SKIP', detail: `already on ${CANONICAL_PORT}` };
+
+  log(`stopping pgserve PID ${info.pid} (port ${info.port})`);
+  try {
+    execSync(`pm2 restart pgserve --update-env -- --port ${CANONICAL_PORT}`, { stdio: 'pipe' });
+    return { status: 'OK', detail: `pm2 restart pgserve on port ${CANONICAL_PORT}` };
+  } catch (pm2Err) {
+    warn(`pm2 restart failed (${pm2Err.message}) — falling back to direct pg_ctl`);
+    try {
+      execSync(`pg_ctl -D ${getDataDir()} -m fast stop`, { stdio: 'pipe' });
+      return { status: 'OK', detail: `stopped pgserve; relaunch via pm2 or autopg install` };
+    } catch (ctlErr) {
+      throw new Error(`port reconcile failed: pm2 (${pm2Err.message}) and pg_ctl (${ctlErr.message})`);
+    }
+  }
+}

package/.claude/context/windows-debug.md

@@ -1,119 +0,0 @@
-# Windows Debug Context
-
-## RESOLVED (2025-12-12)
-
-The Windows router binding issue has been fixed. See "Solution Applied" below.
-
----
-
-## Original Issue
-PostgreSQL starts successfully on port 9432, but the router/proxy on port 8432 was NOT listening.
-Clients could not connect because 8432 wasn't bound.
-
-## Root Causes Found
-
-### 1. `reusePort: true` - Linux-only feature (PRIMARY CAUSE)
-**Location:** `src/cluster.js:75`
-
-The cluster mode uses `Bun.listen({ reusePort: true })` which maps to `SO_REUSEPORT`.
-This socket option is Linux-only and **silently fails on Windows**.
-
-### 2. Auto-enabled cluster mode on multi-core Windows systems
-**Location:** `bin/pglite-server.js:106`
-
-Windows systems with multiple CPU cores automatically entered cluster mode,
-triggering the `reusePort` failure.
-
-### 3. TCP port opens before PostgreSQL ready for protocol handshakes
-**Location:** `src/postgres.js:803-821`
-
-PostgreSQL was marked "ready" when TCP port opened, but it wasn't actually
-ready for protocol-level handshakes. Admin pool connection timed out.
-
----
-
-## Solution Applied
-
-### Fix 1: Disable cluster mode on Windows
-**File:** `bin/pglite-server.js:98-108`
-```javascript
-const isWindows = os.platform() === 'win32';
-cluster: cpuCount > 1 && !isWindows,
-```
-
-### Fix 2: Add platform check to reusePort
-**File:** `src/cluster.js:72-76`
-```javascript
-const isWindows = os.platform() === 'win32';
-this.server = Bun.listen({
-  reusePort: !isWindows,  // SO_REUSEPORT only works on Linux/macOS
-  ...
-});
-```
-
-### Fix 3: Add port binding verification
-**File:** `src/cluster.js:99-102`
-```javascript
-if (!this.server || !this.server.port) {
-  throw new Error(`Failed to bind to port ${this.port} - reusePort may not be supported`);
-}
-```
-
-### Fix 4: Add Windows readiness delay
-**File:** `src/postgres.js:813-817`
-```javascript
-if (isWindows) {
-  await Bun.sleep(2000); // 2 second delay for Windows
-}
-```
-
-### Fix 5: Increase admin pool retry for Windows
-**File:** `src/postgres.js:598-599`
-```javascript
-const maxRetries = isWindows ? 10 : 5;
-const baseDelay = isWindows ? 2000 : 1000;
-```
-
----
-
-## Verification
-
-After applying fixes, server runs correctly on Windows:
-- Router: `127.0.0.1:7432` ✅
-- PostgreSQL: `127.0.0.1:8432` ✅
-- Database auto-provisioning: ✅
-- Query execution: ✅
-
-```
-Server started successfully!
-
-  Endpoint:    postgresql://127.0.0.1:7432/<database>
-  Mode:        In-memory (ephemeral)
-  PostgreSQL:  Port 8432 (internal)
-  Auto-create: Enabled
-```
-
----
-
-## Test Commands (Run from Windows)
-```cmd
-# Build binary
-bun build --compile bin/pglite-server.js --outfile dist/pgserve-windows-x64.exe
-
-# Start server
-dist\pgserve-windows-x64.exe
-
-# Check ports are listening (should see BOTH)
-netstat -an | findstr "LISTEN" | findstr "8432 9432"
-
-# Test connection
-psql postgresql://localhost:8432/testdb
-```
-
----
-
-## Related Files
-- `bin/pglite-server.js` - Entry point, cluster mode decision
-- `src/cluster.js` - Cluster mode with reusePort
-- `src/router.js` - Single-process mode (works on Windows)
-- `src/postgres.js` - PostgreSQL startup and admin pool

package/.genie/AGENTS.md

@@ -1,15 +0,0 @@
----
-name: Base
-label: 🧞 Base
-description: Global agents (orchestration, QA, analysis, maintenance)
-github_url: https://github.com/namastexlabs/automagik-genie/tree/main/.genie
----
-
-> **Shared rules in `~/.claude/rules/agent-bible.md`. Read it.**
-
-# Base Genie Agents
-
-**Global agents available across all collectives.**
-
-For complete orchestration framework and instructions, see:
-@AGENTS.md