exonous 0.0.0-stage → 2.10.4

package/assets/agents/roster.json

@@ -0,0 +1,209 @@
+{
+  "agents": [
+    "exo-designer",
+    "exo-frontend",
+    "exo-backend",
+    "exo-mobile",
+    "exo-data-ai",
+    "exo-devops",
+    "exo-infra",
+    "exo-qa",
+    "exo-security",
+    "exo-pm",
+    "exo-cto",
+    "exo-researcher"
+  ],
+  "tiers": {
+    "exo-designer": "sonnet",
+    "exo-frontend": "opus",
+    "exo-backend": "opus",
+    "exo-mobile": "opus",
+    "exo-data-ai": "opus",
+    "exo-devops": "opus",
+    "exo-infra": "opus",
+    "exo-qa": "sonnet",
+    "exo-security": "sonnet",
+    "exo-pm": "sonnet",
+    "exo-cto": "sonnet",
+    "exo-researcher": "sonnet"
+  },
+  "builtins": {
+    "claude": [
+      "general-purpose",
+      "Explore",
+      "Plan",
+      "statusline-setup",
+      "output-style-setup",
+      "claude-code-guide"
+    ],
+    "cursor": [
+      "generalPurpose",
+      "explore",
+      "shell",
+      "browser-use",
+      "browserUse",
+      "cursor-guide",
+      "ci-investigator",
+      "bugbot",
+      "security-review",
+      "best-of-n-runner"
+    ]
+  },
+  "legacy": {
+    "exo-designer": [
+      "impeccable-asset-producer",
+      "impeccable-documenter",
+      "impeccable-finish-reviewer",
+      "impeccable-manual-edit-applier",
+      "a11y-architect"
+    ],
+    "exo-frontend": [
+      "react-build-resolver",
+      "seo-specialist",
+      "gan-generator"
+    ],
+    "exo-backend": [
+      "cpp-build-resolver",
+      "go-build-resolver",
+      "java-build-resolver",
+      "rust-build-resolver",
+      "django-build-resolver"
+    ],
+    "exo-mobile": [
+      "dart-build-resolver",
+      "kotlin-build-resolver",
+      "swift-build-resolver",
+      "harmonyos-app-resolver"
+    ],
+    "exo-data-ai": [
+      "database-reviewer",
+      "mle-reviewer",
+      "pytorch-build-resolver"
+    ],
+    "exo-devops": [
+      "loop-operator",
+      "harness-optimizer"
+    ],
+    "exo-infra": [
+      "network-architect",
+      "network-config-reviewer",
+      "network-troubleshooter",
+      "homelab-architect"
+    ],
+    "exo-qa": [
+      "code-reviewer",
+      "cpp-reviewer",
+      "csharp-reviewer",
+      "django-reviewer",
+      "fastapi-reviewer",
+      "flutter-reviewer",
+      "fsharp-reviewer",
+      "go-reviewer",
+      "java-reviewer",
+      "kotlin-reviewer",
+      "php-reviewer",
+      "python-reviewer",
+      "react-reviewer",
+      "rust-reviewer",
+      "swift-reviewer",
+      "typescript-reviewer",
+      "vue-reviewer",
+      "tdd-guide",
+      "e2e-runner",
+      "pr-test-analyzer",
+      "silent-failure-hunter",
+      "comment-analyzer",
+      "type-design-analyzer",
+      "agent-evaluator",
+      "gan-evaluator"
+    ],
+    "exo-security": [
+      "security-reviewer",
+      "healthcare-reviewer",
+      "opensource-sanitizer",
+      "opensource-forker"
+    ],
+    "exo-pm": [
+      "planner",
+      "chief-of-staff",
+      "marketing-agent",
+      "spec-miner",
+      "gan-planner"
+    ],
+    "exo-cto": [
+      "architect",
+      "code-architect"
+    ],
+    "exo-researcher": [
+      "code-explorer",
+      "docs-lookup",
+      "doc-updater",
+      "conversation-analyzer",
+      "opensource-packager"
+    ]
+  },
+  "implementers": [
+    "build-error-resolver",
+    "refactor-cleaner",
+    "code-simplifier",
+    "performance-optimizer"
+  ],
+  "domainHints": {
+    "exo-mobile": "\\b(react[- ]native|expo|swiftui|swift|kotlin|android|ios|flutter|dart)\\b",
+    "exo-frontend": "(\\.(vue|tsx|jsx|css|scss|svelte)\\b|\\b(frontend|front-end|component|tailwind|nuxt|next\\.js|vue|react|ui)\\b)",
+    "exo-infra": "\\b(terraform|kubernetes|k8s|helm|network|vpc|dns|cloud ?formation|pulumi)\\b",
+    "exo-devops": "\\b(ci|cd|pipeline|github actions|workflow\\.ya?ml|dockerfile|docker|release|deploy)\\b",
+    "exo-data-ai": "\\b(sql|migration|schema|postgres|mysql|prisma|etl|pipeline data|ml|llm|embedding|pytorch)\\b"
+  },
+  "defaultImplementer": "exo-backend",
+  "nameKeywords": [
+    [
+      "exo-designer",
+      "design|ux|ui-|-ui|visual|a11y|accessib|brand"
+    ],
+    [
+      "exo-mobile",
+      "mobile|ios|android|flutter|dart|swift|kotlin|expo"
+    ],
+    [
+      "exo-frontend",
+      "front|react|vue|nuxt|next|css|web"
+    ],
+    [
+      "exo-data-ai",
+      "data|db|sql|ml|ai-|llm|eval|model"
+    ],
+    [
+      "exo-security",
+      "secur|sanitiz|vuln|threat|pentest|compliance"
+    ],
+    [
+      "exo-infra",
+      "infra|network|cloud|k8s|kube|terraform|homelab"
+    ],
+    [
+      "exo-devops",
+      "devops|ci|deploy|release|pipeline|harness|loop|ops"
+    ],
+    [
+      "exo-qa",
+      "review|test|qa|verif|debug|check|audit|critic|evaluat"
+    ],
+    [
+      "exo-pm",
+      "plan|product|pm|roadmap|spec|requirement|analyst|scrum"
+    ],
+    [
+      "exo-cto",
+      "architect|cto|strateg|advisor|tech-lead"
+    ],
+    [
+      "exo-researcher",
+      "research|explor|doc|writer|map|scout|librarian|intel"
+    ],
+    [
+      "exo-backend",
+      "back|api|server|exec|fix|implement|build|coder|engineer|developer|resolver"
+    ]
+  ]
+}

package/assets/agents/taxis.js

@@ -0,0 +1,189 @@
+#!/usr/bin/env node
+// taxis — enforces the 12 exo-* agents in Claude Code and Cursor.
+// Usage (hook command): node taxis.js <claude|cursor>
+//   PreToolUse (Task/Agent) · Cursor subagentStart → allow roster/builtins, remap legacy names, deny the rest.
+//   SessionStart → move stray agent files (other plugins) out of ~/.claude/agents and ~/.cursor/agents
+//   into ~/.claude/exonous/agent-roles/, where exo-* agents load them as role briefs.
+// Fails open: a guard bug must never block the user's session.
+
+'use strict';
+
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+
+const HOME = os.homedir();
+const ROLES_DIR = path.join(HOME, '.claude', 'exonous', 'agent-roles');
+const AGENT_DIRS = [path.join(HOME, '.claude', 'agents'), path.join(HOME, '.cursor', 'agents')];
+const runtime = process.argv[2] === 'cursor' ? 'cursor' : 'claude';
+
+function loadRoster() {
+  return JSON.parse(fs.readFileSync(path.join(__dirname, 'roster.json'), 'utf8'));
+}
+
+function routeByDomain(roster, text) {
+  for (const [agent, pattern] of Object.entries(roster.domainHints)) {
+    if (new RegExp(pattern, 'i').test(text)) return agent;
+  }
+  return roster.defaultImplementer;
+}
+
+function resolve(roster, requested, prompt) {
+  if (!requested) return { action: 'allow' };
+  const bare = requested.includes(':') ? requested.split(':').pop() : requested;
+  if (roster.agents.includes(bare)) {
+    return bare === requested ? { action: 'allow' } : { action: 'remap', target: bare };
+  }
+  if (roster.builtins[runtime].includes(requested)) return { action: 'allow' };
+
+  for (const [target, names] of Object.entries(roster.legacy)) {
+    if (names.includes(bare)) return { action: 'remap', target, legacy: bare };
+  }
+  if (roster.implementers.includes(bare)) {
+    return { action: 'remap', target: routeByDomain(roster, prompt), legacy: bare };
+  }
+  const lower = bare.toLowerCase();
+  for (const [target, pattern] of roster.nameKeywords) {
+    if (!new RegExp(pattern).test(lower)) continue;
+    const routed = target === roster.defaultImplementer ? routeByDomain(roster, prompt) : target;
+    return { action: 'remap', target: routed, legacy: bare };
+  }
+  return { action: 'deny' };
+}
+
+function findBrief(name) {
+  let groups;
+  try {
+    groups = fs.readdirSync(ROLES_DIR, { withFileTypes: true }).filter((e) => e.isDirectory());
+  } catch {
+    return null;
+  }
+  for (const group of groups) {
+    const candidate = path.join(ROLES_DIR, group.name, `${name}.md`);
+    if (fs.existsSync(candidate)) return candidate;
+  }
+  return null;
+}
+
+function remapPrompt(prompt, legacy) {
+  if (!legacy) return prompt;
+  const brief = findBrief(legacy);
+  const header = brief
+    ? `[taxis] Running the legacy \`${legacy}\` role. Read ${brief} first and follow its contract (inputs, outputs, files written); your exo-* agent guidelines still apply.`
+    : `[taxis] Requested as \`${legacy}\`.`;
+  return `${header}\n\n${prompt || ''}`;
+}
+
+function denyMessage(roster, requested) {
+  return `Agent "${requested}" is outside the Exonous roster. Use one of: ${roster.agents.join(', ')}.`;
+}
+
+function freeName(dir, file) {
+  const base = file.slice(0, -3);
+  let candidate = path.join(dir, file);
+  for (let n = 1; fs.existsSync(candidate); n += 1) candidate = path.join(dir, `${base}.${n}.md`);
+  return candidate;
+}
+
+function sweep(roster) {
+  let moved = 0;
+  for (const dir of AGENT_DIRS) {
+    let entries;
+    try {
+      entries = fs.readdirSync(dir);
+    } catch {
+      continue;
+    }
+    for (const file of entries) {
+      if (!file.endsWith('.md') || roster.agents.includes(file.slice(0, -3))) continue;
+      const src = path.join(dir, file);
+      if (!fs.lstatSync(src).isFile()) continue;
+      const group = file.startsWith('impeccable-') ? 'impeccable' : 'quarantine';
+      fs.mkdirSync(path.join(ROLES_DIR, group), { recursive: true });
+      fs.copyFileSync(src, group === 'quarantine' ? freeName(path.join(ROLES_DIR, group), file) : path.join(ROLES_DIR, group, file));
+      fs.unlinkSync(src);
+      moved += 1;
+    }
+  }
+  return moved;
+}
+
+function emit(obj) {
+  if (obj) process.stdout.write(JSON.stringify(obj));
+  process.exit(0);
+}
+
+// Model governance: in Claude Code a per-call `model` override must match the agent's tier.
+// Cursor model slugs are user-selected, so its calls keep their model.
+function governModel(roster, input) {
+  const tier = roster.tiers[input.subagent_type];
+  if (runtime !== 'claude' || !tier || !input.model || input.model === tier) return input;
+  return { ...input, model: tier };
+}
+
+function handleSpawn(roster, toolInput) {
+  const requested = toolInput.subagent_type;
+  const decision = resolve(roster, requested, toolInput.prompt || '');
+
+  if (decision.action === 'allow') {
+    const governed = governModel(roster, toolInput);
+    if (governed !== toolInput) {
+      emit({ hookSpecificOutput: { hookEventName: 'PreToolUse', permissionDecision: 'allow', permissionDecisionReason: `taxis: ${requested} runs on ${governed.model}`, updatedInput: governed } });
+    }
+    emit(runtime === 'cursor' ? { permission: 'allow' } : null);
+  }
+
+  if (decision.action === 'remap') {
+    const updated = governModel(roster, { ...toolInput, subagent_type: decision.target, prompt: remapPrompt(toolInput.prompt, decision.legacy) });
+    const reason = `taxis: ${requested} → ${decision.target}`;
+    emit(runtime === 'cursor'
+      ? { permission: 'allow', updated_input: updated }
+      : { hookSpecificOutput: { hookEventName: 'PreToolUse', permissionDecision: 'allow', permissionDecisionReason: reason, updatedInput: updated } });
+  }
+
+  const message = denyMessage(roster, requested);
+  emit(runtime === 'cursor'
+    ? { permission: 'deny', user_message: message, agent_message: message }
+    : { hookSpecificOutput: { hookEventName: 'PreToolUse', permissionDecision: 'deny', permissionDecisionReason: message } });
+}
+
+function main() {
+  let input;
+  try {
+    input = JSON.parse(fs.readFileSync(0, 'utf8') || '{}');
+  } catch {
+    emit(runtime === 'cursor' ? { permission: 'allow' } : null);
+  }
+  // Cursor also runs ~/.claude/settings.json hooks; the native ~/.cursor/hooks.json entry does the work there.
+  if (runtime === 'claude' && input.cursor_version) emit({});
+
+  const roster = loadRoster();
+  const event = String(input.hook_event_name || '').toLowerCase();
+
+  if (event === 'sessionstart') {
+    sweep(roster);
+    emit(runtime === 'cursor' ? {} : null);
+  }
+
+  if (event === 'subagentstart') {
+    const decision = resolve(roster, input.subagent_type, input.task || '');
+    if (decision.action === 'allow') emit({ permission: 'allow' });
+    const message = decision.action === 'remap'
+      ? `Agent "${input.subagent_type}" is folded into ${decision.target}; spawn ${decision.target} instead.`
+      : denyMessage(roster, input.subagent_type);
+    emit({ permission: 'deny', user_message: message });
+  }
+
+  if (event === 'pretooluse' && ['Task', 'Agent'].includes(input.tool_name)) {
+    handleSpawn(roster, input.tool_input || {});
+  }
+
+  emit(runtime === 'cursor' ? { permission: 'allow' } : null);
+}
+
+try {
+  main();
+} catch (err) {
+  process.stderr.write(`[taxis] guard error (failing open): ${err.message}\n`);
+  emit(runtime === 'cursor' ? { permission: 'allow' } : null);
+}

package/assets/editors/cursor/frontend-skills.mdc

@@ -0,0 +1,27 @@
+---
+description: Mandatory design stack (ui-design + ui-motion + native-ui + ui-mockup) as the DESIGN authority for UI work; ui-patterns subordinate for charts, forms, web navigation and stack guidelines
+alwaysApply: true
+---
+
+# Frontend Skills (mandatory)
+
+On ANY frontend/UI task — pages, components, styling, layout, redesign, polish, landing, dashboard, CSS/Tailwind, React/Next/Vue UI, native screens:
+
+**Source of truth for DESIGN** = the design stack (`~/.agents/skills/<name>/SKILL.md`, symlinked into `~/.claude/skills/` and `~/.cursor/skills/`):
+
+1. **`ui-design`** — always first. Direction, modes, critique/audit, refine commands, live iteration, and the hook-enforced detector (`node scripts/ui-design.mjs`). Style modules in `reference/styles/` (direction for landing/portfolio/marketing, redesign for brownfield, premium/minimalist/brutalist when the brief asks). Dashboards and tools follow its Operate mode, not the style modules.
+2. **`ui-motion`** — any animation, transition, gesture, toast, or interaction-feel work (web and Expo).
+3. **`native-ui`** — iOS/Android/desktop-native feel, Apple-quality design, Swift/SwiftUI.
+4. **`ui-mockup`** — image-model comps, image-to-code, brand kits — only when the brief calls for imagery.
+
+Then:
+
+5. **`ui-patterns`** (subordinate) — consult **only after the stack sets direction**, and only for charts/data visualization, form UX patterns, web navigation patterns, and stack implementation guidelines (Vue, Nuxt, React, Next.js, React Native, shadcn/ui, Tailwind). Never sets visual direction.
+
+**On conflict between ui-patterns and the design stack, ALWAYS prefer the stack.**
+
+Announce: `Using ui-design for [purpose]` — name the companion skills actually loaded (`+ ui-motion`, `+ native-ui`, `+ ui-mockup`, `+ ui-patterns`).
+
+Before delivery, after ui-design's polish/audit pass, run the ui-patterns pre-delivery add-on (cursor-pointer on non-button clickables, chart legend + non-color encoding + table fallback, form a11y, focus on route change, z-index scale).
+
+Skip only for pure backend/infra with zero UI surface. Existing project design systems still win for tokens/components — skills guide quality and direction, not invent a second system.

package/assets/editors/hooks/cursor/hooks.json

@@ -0,0 +1,11 @@
+{
+  "version": 1,
+  "hooks": {
+    "preToolUse": [
+      {
+        "command": "__UI_DESIGN_HOOK__",
+        "timeout": 5
+      }
+    ]
+  }
+}

package/assets/machine/PR-TEMPLATE.md

@@ -0,0 +1,21 @@
+<!-- PR body template (PT-BR). Hook checks the 5 titles below; max 30 changed files per PR. -->
+
+## Resumo
+
+<!-- 1–2 frases sobre o objetivo da PR -->
+
+## Principais mudanças
+
+<!-- bullets do que foi adicionado/alterado/removido -->
+
+## Arquitetura & implementação
+
+<!-- breve: decisões que ajudam a entender o diff -->
+
+## Antes → Agora
+
+<!-- tabela ou bullets; se não aplicável: _N/A — não aplicável a esta mudança_ -->
+
+## Roteiro de teste
+
+<!-- passos objetivos para validar -->

package/assets/machine/hooks/anamnesis.cjs

@@ -0,0 +1,61 @@
+#!/usr/bin/env node
+'use strict';
+
+// anamnesis — automatic session memory hook: --event start|prompt|tool|stop|end --adapter <tool>. Always exits 0.
+const EVENTS = ['start', 'prompt', 'tool', 'stop', 'end'];
+// Session-start output per tool; windsurf and opencode have no channel back to the model.
+const FORMATS = {
+  claude: (text) => JSON.stringify({ hookSpecificOutput: { hookEventName: 'SessionStart', additionalContext: text } }),
+  gemini: (text) => JSON.stringify({ hookSpecificOutput: { hookEventName: 'SessionStart', additionalContext: text } }),
+  cursor: (text) => JSON.stringify({ additional_context: text }),
+  copilot: (text) => JSON.stringify({ additionalContext: text }),
+  codex: (text) => text,
+};
+
+function arg(name) {
+  const i = process.argv.indexOf(name);
+  return i === -1 ? null : process.argv[i + 1] || null;
+}
+
+function readStdin() {
+  try {
+    return require('fs').readFileSync(0, 'utf8');
+  } catch {
+    return '';
+  }
+}
+
+function logError(err) {
+  try {
+    const fs = require('fs');
+    const path = require('path');
+    const dir = path.join(require('./lib/paths.cjs').stateDir(), 'anamnesis');
+    fs.mkdirSync(dir, { recursive: true, mode: 0o700 });
+    fs.writeFileSync(path.join(dir, 'last-error'), `${new Date().toISOString()} ${arg('--event')} ${arg('--adapter')}: ${err && err.stack ? err.stack : err}\n`);
+  } catch {
+    // nowhere left to report
+  }
+}
+
+function main() {
+  const event = arg('--event');
+  const adapter = (arg('--adapter') || 'claude').replace(/[^\w-]/g, '');
+  if (!EVENTS.includes(event)) return;
+  let input = {};
+  try {
+    const parsed = JSON.parse(readStdin() || '{}');
+    if (parsed && typeof parsed === 'object' && !Array.isArray(parsed)) input = parsed;
+  } catch {
+    // unreadable payload: cwd falls back to the process cwd
+  }
+  const brief = require('./lib/memory.cjs').handle(event, input, { agent: adapter });
+  if (brief && FORMATS[adapter]) process.stdout.write(`${FORMATS[adapter](brief)}\n`);
+}
+
+try {
+  main();
+} catch (err) {
+  // a session must go on even when memory breaks
+  logError(err);
+}
+process.exit(0);

package/assets/machine/hooks/ethos.cjs

@@ -0,0 +1,48 @@
+#!/usr/bin/env node
+'use strict';
+
+// ethos — restates the always-on rule set on each prompt: --adapter <tool>. Always exits 0.
+const REMINDER = 'exonous rules in force (nomos + praxis): terse; smallest change; reuse first; close scope; locate before reading; test first, fix cause, prove; commit/push only when asked.';
+// Prompt-submit output per tool; windsurf and opencode have no channel back to the model, so they are not wired.
+const FORMATS = {
+  claude: (text) => JSON.stringify({ hookSpecificOutput: { hookEventName: 'UserPromptSubmit', additionalContext: text } }),
+  gemini: (text) => JSON.stringify({ hookSpecificOutput: { hookEventName: 'BeforeAgent', additionalContext: text } }),
+  cursor: (text) => JSON.stringify({ additional_context: text }),
+  copilot: (text) => JSON.stringify({ additionalContext: text }),
+  codex: (text) => text,
+};
+
+function arg(name) {
+  const i = process.argv.indexOf(name);
+  return i === -1 ? null : process.argv[i + 1] || null;
+}
+
+function readJson(file) {
+  try {
+    return JSON.parse(require('fs').readFileSync(file, 'utf8'));
+  } catch {
+    return null;
+  }
+}
+
+/** Opted out with EXONOUS_RULES_REMINDER=0 or config.json `"rulesReminder": false`. */
+function disabled(env = process.env) {
+  if (env.EXONOUS_RULES_REMINDER === '0') return true;
+  const path = require('path');
+  const config = readJson(path.join(require('./lib/paths.cjs').exoDir(), 'config.json'));
+  return Boolean(config) && typeof config === 'object' && config.rulesReminder === false;
+}
+
+function main() {
+  if (disabled()) return;
+  // hasOwn, or an inherited key (`toString`, `constructor`) would write junk into the model's context.
+  const adapter = (arg('--adapter') || 'claude').replace(/[^\w-]/g, '');
+  if (Object.hasOwn(FORMATS, adapter)) process.stdout.write(`${FORMATS[adapter](REMINDER)}\n`);
+}
+
+try {
+  main();
+} catch {
+  // a prompt must go through even when the reminder cannot be written
+}
+process.exit(0);

package/assets/machine/hooks/kairos.cjs

@@ -0,0 +1,46 @@
+#!/usr/bin/env node
+'use strict';
+
+// kairos — session hook: prints the last update note (one line) and starts a detached daily update. Always exits 0.
+const { spawn } = require('child_process');
+
+function arg(name) {
+  const i = process.argv.indexOf(name);
+  return i === -1 ? null : process.argv[i + 1] || null;
+}
+
+// Tools that fire kairos where stdout reaches nobody (every prompt, a detached plugin spawn) only trigger the check.
+const SILENT = ['windsurf', 'opencode'];
+const FORMATS = {
+  cursor: (note) => JSON.stringify({ additional_context: note }),
+  gemini: (note) => JSON.stringify({ hookSpecificOutput: { hookEventName: 'SessionStart', additionalContext: note } }),
+  copilot: (note) => JSON.stringify({ additionalContext: note }),
+};
+
+function startUpdate(selfupdate, adapter) {
+  if (selfupdate.optedOut() || !selfupdate.due()) return;
+  selfupdate.markChecked();
+  spawn(process.execPath, [__filename, '--run', '--adapter', adapter], { detached: true, stdio: 'ignore', windowsHide: true }).unref();
+}
+
+function main() {
+  const selfupdate = require('./lib/selfupdate.cjs');
+  if (selfupdate.notOwner()) return;
+  const adapter = (arg('--adapter') || 'claude').replace(/[^\w-]/g, '');
+  if (process.argv.includes('--run')) {
+    selfupdate.run({ background: true });
+    return;
+  }
+  if (!SILENT.includes(adapter)) {
+    const note = selfupdate.takeNote();
+    if (note) process.stdout.write(`${FORMATS[adapter] ? FORMATS[adapter](note) : note}\n`);
+  }
+  startUpdate(selfupdate, adapter);
+}
+
+try {
+  main();
+} catch {
+  // a session must start even when the hook breaks
+}
+process.exit(0);