@soleri/cli 1.8.0 → 1.9.0

package/code-reviewer/src/activation/activate.ts

@@ -0,0 +1,125 @@
+import { join } from 'node:path';
+import { homedir } from 'node:os';
+import { PERSONA } from '../identity/persona.js';
+import { hasAgentMarker, removeClaudeMdGlobal } from './inject-claude-md.js';
+import type { Vault, Planner, Plan } from '@soleri/core';
+
+export interface ActivationResult {
+  activated: boolean;
+  persona: {
+    name: string;
+    role: string;
+    description: string;
+    greeting: string;
+  };
+  guidelines: string[];
+  tool_recommendations: Array<{ intent: string; facade: string; op: string }>;
+  session_instruction: string;
+  setup_status: {
+    claude_md_injected: boolean;
+    global_claude_md_injected: boolean;
+    vault_has_entries: boolean;
+    vault_entry_count: number;
+  };
+  executing_plans: Array<{ id: string; objective: string; tasks: number; completed: number }>;
+  next_steps: string[];
+}
+
+export interface DeactivationResult {
+  deactivated: boolean;
+  message: string;
+  cleanup?: {
+    globalClaudeMd: boolean;
+  };
+}
+
+/**
+ * Activate Code Reviewer — returns full context for Claude to adopt the persona.
+ */
+export function activateAgent(vault: Vault, projectPath: string, planner?: Planner): ActivationResult {
+  // Check CLAUDE.md injection status (project-level and global)
+  const projectClaudeMd = join(projectPath, 'CLAUDE.md');
+  const globalClaudeMd = join(homedir(), '.claude', 'CLAUDE.md');
+  const claudeMdInjected = hasAgentMarker(projectClaudeMd);
+  const globalClaudeMdInjected = hasAgentMarker(globalClaudeMd);
+
+  // Check vault status
+  const stats = vault.stats();
+  const vaultHasEntries = stats.totalEntries > 0;
+
+  // Build next steps based on what's missing
+  const nextSteps: string[] = [];
+  if (!globalClaudeMdInjected && !claudeMdInjected) {
+    nextSteps.push('No CLAUDE.md configured — run inject_claude_md with global: true for all projects, or without for this project only');
+  } else if (!globalClaudeMdInjected) {
+    nextSteps.push('Global CLAUDE.md not configured — run inject_claude_md with global: true to enable activation in all projects');
+  }
+  if (!vaultHasEntries) {
+    nextSteps.push('Vault is empty — start capturing knowledge with the domain capture ops');
+  }
+  if (nextSteps.length === 0) {
+    nextSteps.push('All set! Code Reviewer is fully integrated.');
+  }
+
+  // Check for executing plans
+  const executingPlans = planner ? planner.getExecuting().map((p) => ({
+    id: p.id,
+    objective: p.objective,
+    tasks: p.tasks.length,
+    completed: p.tasks.filter((t) => t.status === 'completed').length,
+  })) : [];
+  if (executingPlans.length > 0) {
+    nextSteps.unshift(`${executingPlans.length} plan(s) in progress — use get_plan to review`);
+  }
+
+  return {
+    activated: true,
+    persona: {
+      name: PERSONA.name,
+      role: PERSONA.role,
+      description: PERSONA.description,
+      greeting: PERSONA.greeting,
+    },
+    guidelines: [
+      'Actionable feedback only',
+      'Respect existing patterns',
+      'Simplicity over cleverness',
+    ],
+    tool_recommendations: [
+      { intent: 'health check', facade: 'code-reviewer_core', op: 'health' },
+      { intent: 'search all', facade: 'code-reviewer_core', op: 'search' },
+      { intent: 'vault stats', facade: 'code-reviewer_core', op: 'vault_stats' },
+      { intent: 'search code-review', facade: 'code-reviewer_code_review', op: 'search' },
+      { intent: 'code-review patterns', facade: 'code-reviewer_code_review', op: 'get_patterns' },
+      { intent: 'capture code-review', facade: 'code-reviewer_code_review', op: 'capture' },
+      { intent: 'search architecture', facade: 'code-reviewer_architecture', op: 'search' },
+      { intent: 'architecture patterns', facade: 'code-reviewer_architecture', op: 'get_patterns' },
+      { intent: 'capture architecture', facade: 'code-reviewer_architecture', op: 'capture' },
+    ],
+    session_instruction: 'You are now ' + PERSONA.name + ', a ' + PERSONA.role + '. Stay in character for the ENTIRE session. ' +
+      'Reference patterns from the knowledge vault. Provide concrete examples. Flag anti-patterns with severity.',
+    setup_status: {
+      claude_md_injected: claudeMdInjected,
+      global_claude_md_injected: globalClaudeMdInjected,
+      vault_has_entries: vaultHasEntries,
+      vault_entry_count: stats.totalEntries,
+    },
+    executing_plans: executingPlans,
+    next_steps: nextSteps,
+  };
+}
+
+/**
+ * Deactivate Code Reviewer — drops persona and cleans up CLAUDE.md sections.
+ */
+export function deactivateAgent(): DeactivationResult {
+  // Remove agent sections from global CLAUDE.md on deactivation
+  const globalResult = removeClaudeMdGlobal();
+  return {
+    deactivated: true,
+    message: 'Goodbye! ' + PERSONA.name + ' persona deactivated. Reverting to default behavior.',
+    cleanup: {
+      globalClaudeMd: globalResult.removed,
+    },
+  };
+}

package/code-reviewer/src/activation/claude-md-content.ts

@@ -0,0 +1,217 @@
+/**
+ * CLAUDE.md content for Code Reviewer.
+ * Generated by Soleri — do not edit manually.
+ */
+export function getClaudeMdContent(): string {
+  return [
+    '<!-- code-reviewer:mode -->',
+    '',
+    '# Code Reviewer Mode',
+    '',
+    '## Code Reviewer Integration',
+    '',
+    '**Activate:** "Hello, Code Reviewer!" → `code-reviewer_core op:activate params:{ projectPath: "." }`',
+    '**Deactivate:** "Goodbye, Code Reviewer!" → `code-reviewer_core op:activate params:{ deactivate: true }`',
+    '',
+    'On activation, adopt the returned persona. Stay in character until deactivated.',
+    '',
+    '## Session Start',
+    '',
+    'On every new session: `code-reviewer_core op:register params:{ projectPath: "." }`',
+    '',
+    '## Facades',
+    '',
+    '| Need | Facade | Op |',
+    '|------|--------|----|',
+    '| Health check | `code-reviewer_core` | `health` |',
+    '| Search all | `code-reviewer_core` | `search` |',
+    '| Vault stats | `code-reviewer_core` | `vault_stats` |',
+    '| Identity | `code-reviewer_core` | `identity` |',
+    '| code-review patterns | `code-reviewer_code_review` | `get_patterns` |',
+    '| Search code-review | `code-reviewer_code_review` | `search` |',
+    '| Capture code-review | `code-reviewer_code_review` | `capture` |',
+    '| architecture patterns | `code-reviewer_architecture` | `get_patterns` |',
+    '| Search architecture | `code-reviewer_architecture` | `search` |',
+    '| Capture architecture | `code-reviewer_architecture` | `capture` |',
+    '| Memory search | `code-reviewer_core` | `memory_search` |',
+    '| Memory capture | `code-reviewer_core` | `memory_capture` |',
+    '| Memory list | `code-reviewer_core` | `memory_list` |',
+    '| Session capture | `code-reviewer_core` | `session_capture` |',
+    '| Export knowledge | `code-reviewer_core` | `export` |',
+    '| Record feedback | `code-reviewer_core` | `record_feedback` |',
+    '| Enhanced feedback | `code-reviewer_core` | `brain_feedback` |',
+    '| Feedback stats | `code-reviewer_core` | `brain_feedback_stats` |',
+    '| Reset extracted | `code-reviewer_core` | `brain_reset_extracted` |',
+    '| Rebuild vocabulary | `code-reviewer_core` | `rebuild_vocabulary` |',
+    '| Brain stats | `code-reviewer_core` | `brain_stats` |',
+    '| LLM status | `code-reviewer_core` | `llm_status` |',
+    '| Create plan | `code-reviewer_core` | `create_plan` |',
+    '| Get plan | `code-reviewer_core` | `get_plan` |',
+    '| Approve plan | `code-reviewer_core` | `approve_plan` |',
+    '| Update task | `code-reviewer_core` | `update_task` |',
+    '| Complete plan | `code-reviewer_core` | `complete_plan` |',
+    '| Route intent | `code-reviewer_core` | `route_intent` |',
+    '| Morph mode | `code-reviewer_core` | `morph` |',
+    '| Get behavior rules | `code-reviewer_core` | `get_behavior_rules` |',
+    '| Get identity | `code-reviewer_core` | `get_identity` |',
+    '| Update identity | `code-reviewer_core` | `update_identity` |',
+    '| Add guideline | `code-reviewer_core` | `add_guideline` |',
+    '| Remove guideline | `code-reviewer_core` | `remove_guideline` |',
+    '| Rollback identity | `code-reviewer_core` | `rollback_identity` |',
+    '| Cognee status | `code-reviewer_core` | `cognee_status` |',
+    '| Cognee search | `code-reviewer_core` | `cognee_search` |',
+    '| Cognee add | `code-reviewer_core` | `cognee_add` |',
+    '| Cognee cognify | `code-reviewer_core` | `cognee_cognify` |',
+    '| Cognee config | `code-reviewer_core` | `cognee_config` |',
+    '| LLM rotate key | `code-reviewer_core` | `llm_rotate` |',
+    '| LLM call | `code-reviewer_core` | `llm_call` |',
+    '| Governance policy | `code-reviewer_core` | `governance_policy` |',
+    '| Governance proposals | `code-reviewer_core` | `governance_proposals` |',
+    '| Governance stats | `code-reviewer_core` | `governance_stats` |',
+    '| Expire proposals | `code-reviewer_core` | `governance_expire` |',
+    '| Governance dashboard | `code-reviewer_core` | `governance_dashboard` |',
+    '| Iterate plan | `code-reviewer_core` | `plan_iterate` |',
+    '| Split plan tasks | `code-reviewer_core` | `plan_split` |',
+    '| Reconcile plan | `code-reviewer_core` | `plan_reconcile` |',
+    '| Complete lifecycle | `code-reviewer_core` | `plan_complete_lifecycle` |',
+    '| Dispatch tasks | `code-reviewer_core` | `plan_dispatch` |',
+    '| Review plan | `code-reviewer_core` | `plan_review` |',
+    '| Archive plan | `code-reviewer_core` | `plan_archive` |',
+    '| List plan tasks | `code-reviewer_core` | `plan_list_tasks` |',
+    '| Plan stats | `code-reviewer_core` | `plan_stats` |',
+    '| Delete memory | `code-reviewer_core` | `memory_delete` |',
+    '| Memory stats | `code-reviewer_core` | `memory_stats` |',
+    '| Export memories | `code-reviewer_core` | `memory_export` |',
+    '| Import memories | `code-reviewer_core` | `memory_import` |',
+    '| Prune memories | `code-reviewer_core` | `memory_prune` |',
+    '| Deduplicate memories | `code-reviewer_core` | `memory_deduplicate` |',
+    '| Memory topics | `code-reviewer_core` | `memory_topics` |',
+    '| Memories by project | `code-reviewer_core` | `memory_by_project` |',
+    '| Get vault entry | `code-reviewer_core` | `vault_get` |',
+    '| Update entry | `code-reviewer_core` | `vault_update` |',
+    '| Remove entry | `code-reviewer_core` | `vault_remove` |',
+    '| Bulk add | `code-reviewer_core` | `vault_bulk_add` |',
+    '| Bulk remove | `code-reviewer_core` | `vault_bulk_remove` |',
+    '| Vault tags | `code-reviewer_core` | `vault_tags` |',
+    '| Vault domains | `code-reviewer_core` | `vault_domains` |',
+    '| Recent entries | `code-reviewer_core` | `vault_recent` |',
+    '| Import entries | `code-reviewer_core` | `vault_import` |',
+    '| Seed entries | `code-reviewer_core` | `vault_seed` |',
+    '| Backup vault | `code-reviewer_core` | `vault_backup` |',
+    '| Vault age report | `code-reviewer_core` | `vault_age_report` |',
+    '| Admin health | `code-reviewer_core` | `admin_health` |',
+    '| Tool list | `code-reviewer_core` | `admin_tool_list` |',
+    '| Config | `code-reviewer_core` | `admin_config` |',
+    '| Vault size | `code-reviewer_core` | `admin_vault_size` |',
+    '| Uptime | `code-reviewer_core` | `admin_uptime` |',
+    '| Version | `code-reviewer_core` | `admin_version` |',
+    '| Reset cache | `code-reviewer_core` | `admin_reset_cache` |',
+    '| Diagnostic | `code-reviewer_core` | `admin_diagnostic` |',
+    '| Start loop | `code-reviewer_core` | `loop_start` |',
+    '| Loop iterate | `code-reviewer_core` | `loop_iterate` |',
+    '| Loop status | `code-reviewer_core` | `loop_status` |',
+    '| Cancel loop | `code-reviewer_core` | `loop_cancel` |',
+    '| Loop history | `code-reviewer_core` | `loop_history` |',
+    '| Loop active | `code-reviewer_core` | `loop_is_active` |',
+    '| Complete loop | `code-reviewer_core` | `loop_complete` |',
+    '| Orchestrate plan | `code-reviewer_core` | `orchestrate_plan` |',
+    '| Orchestrate execute | `code-reviewer_core` | `orchestrate_execute` |',
+    '| Orchestrate complete | `code-reviewer_core` | `orchestrate_complete` |',
+    '| Orchestrate status | `code-reviewer_core` | `orchestrate_status` |',
+    '| Quick capture | `code-reviewer_core` | `orchestrate_quick_capture` |',
+    '| Capture knowledge | `code-reviewer_core` | `capture_knowledge` |',
+    '| Quick capture entry | `code-reviewer_core` | `capture_quick` |',
+    '| Intelligent search | `code-reviewer_core` | `search_intelligent` |',
+    '| Search feedback | `code-reviewer_core` | `search_feedback` |',
+    '| Grade plan | `code-reviewer_core` | `plan_grade` |',
+    '| Check history | `code-reviewer_core` | `plan_check_history` |',
+    '| Latest check | `code-reviewer_core` | `plan_latest_check` |',
+    '| Meets grade | `code-reviewer_core` | `plan_meets_grade` |',
+    '| Auto improve plan | `code-reviewer_core` | `plan_auto_improve` |',
+    '| Telemetry stats | `code-reviewer_core` | `admin_telemetry` |',
+    '| Recent calls | `code-reviewer_core` | `admin_telemetry_recent` |',
+    '| Reset telemetry | `code-reviewer_core` | `admin_telemetry_reset` |',
+    '| Permissions | `code-reviewer_core` | `admin_permissions` |',
+    '| Vault analytics | `code-reviewer_core` | `admin_vault_analytics` |',
+    '| Search insights | `code-reviewer_core` | `admin_search_insights` |',
+    '| Module status | `code-reviewer_core` | `admin_module_status` |',
+    '| Environment | `code-reviewer_core` | `admin_env` |',
+    '| Garbage collect | `code-reviewer_core` | `admin_gc` |',
+    '| Export config | `code-reviewer_core` | `admin_export_config` |',
+    '| Entry history | `code-reviewer_core` | `curator_entry_history` |',
+    '| Record snapshot | `code-reviewer_core` | `curator_record_snapshot` |',
+    '| Queue stats | `code-reviewer_core` | `curator_queue_stats` |',
+    '| Enrich metadata | `code-reviewer_core` | `curator_enrich` |',
+    '| Get project | `code-reviewer_core` | `project_get` |',
+    '| List projects | `code-reviewer_core` | `project_list` |',
+    '| Unregister project | `code-reviewer_core` | `project_unregister` |',
+    '| Project rules | `code-reviewer_core` | `project_get_rules` |',
+    '| All project rules | `code-reviewer_core` | `project_list_rules` |',
+    '| Add rule | `code-reviewer_core` | `project_add_rule` |',
+    '| Remove rule | `code-reviewer_core` | `project_remove_rule` |',
+    '| Link projects | `code-reviewer_core` | `project_link` |',
+    '| Unlink projects | `code-reviewer_core` | `project_unlink` |',
+    '| Project links | `code-reviewer_core` | `project_get_links` |',
+    '| Linked projects | `code-reviewer_core` | `project_linked_projects` |',
+    '| Touch project | `code-reviewer_core` | `project_touch` |',
+    '| Promote to global | `code-reviewer_core` | `memory_promote_to_global` |',
+    '| Configure memory | `code-reviewer_core` | `memory_configure` |',
+    '| Cross-project search | `code-reviewer_core` | `memory_cross_project_search` |',
+    '',
+    '## Auto-Routing',
+    '',
+    'A UserPromptSubmit hook auto-classifies every prompt via keyword matching.',
+    'When you see a `[MODE-NAME]` indicator in the system context:',
+    '',
+    '1. Call `code-reviewer_core op:route_intent params:{ prompt: "<user message>" }` to get full behavior rules',
+    '2. Follow the returned behavior rules for the detected mode',
+    '3. Briefly acknowledge mode changes in your response (e.g., "Switching to FIX-MODE")',
+    '',
+    'Available modes: FIX-MODE, BUILD-MODE, IMPROVE-MODE, DELIVER-MODE, REVIEW-MODE, PLAN-MODE, DESIGN-MODE, VALIDATE-MODE, EXPLORE-MODE, GENERAL-MODE.',
+    'GENERAL-MODE means the hook detected a work task but could not classify a specific mode — route_intent will refine it.',
+    '',
+    '## Intent Detection',
+    '',
+    '| Signal | Intent |',
+    '|--------|--------|',
+    '| Problem described ("broken", "janky", "weird") | FIX |',
+    '| Need expressed ("I need", "we should have") | BUILD |',
+    '| Quality questioned ("is this right?") | REVIEW |',
+    '| Advice sought ("how should I", "best way") | PLAN |',
+    '| Improvement requested ("make it faster") | IMPROVE |',
+    '',
+    '## Knowledge Protocol',
+    '',
+    'When seeking guidance: vault before codebase before web.',
+    '',
+    '1. Search vault — `code-reviewer_core op:search`',
+    '2. Codebase — only if vault has nothing',
+    '3. Web — last resort',
+    '',
+    '## Knowledge Capture',
+    '',
+    'When learning something that should persist, use the domain capture ops.',
+    '',
+    '## Session Capture',
+    '',
+    'A PreCompact hook is configured to call `session_capture` before context compaction.',
+    'This automatically preserves session summaries as memories for future sessions.',
+    'To manually capture: `code-reviewer_core op:session_capture params:{ summary: "..." }`',
+    '',
+    '## Planning',
+    '',
+    'For multi-step tasks, use the planning system:',
+    '1. Create: `code-reviewer_core op:create_plan params:{ objective: "...", scope: "...", tasks: [...] }`',
+    '2. Approve: `code-reviewer_core op:approve_plan params:{ planId: "...", startExecution: true }`',
+    '3. Track: `code-reviewer_core op:update_task params:{ planId: "...", taskId: "...", status: "completed" }`',
+    '4. Complete: `code-reviewer_core op:complete_plan params:{ planId: "..." }`',
+    '',
+    'Check activation response for recovered plans in `executing` state — remind the user.',
+    '',
+    '<!-- /code-reviewer:mode -->',
+  ].join('\n');
+}
+
+export function getClaudeMdMarker(): string {
+  return 'code-reviewer:mode';
+}

package/code-reviewer/src/activation/inject-claude-md.ts

@@ -0,0 +1,113 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+import { getClaudeMdContent, getClaudeMdMarker } from './claude-md-content.js';
+
+export interface InjectResult {
+  injected: boolean;
+  path: string;
+  action: 'created' | 'updated' | 'appended';
+}
+
+/**
+ * Inject into a specific CLAUDE.md file path.
+ * Shared logic for both project-level and global injection.
+ */
+function injectIntoFile(filePath: string): InjectResult {
+  const content = getClaudeMdContent();
+  const marker = getClaudeMdMarker();
+  const startMarker = '<!-- ' + marker + ' -->';
+  const endMarker = '<!-- /' + marker + ' -->';
+
+  if (!existsSync(filePath)) {
+    writeFileSync(filePath, content + '\n', 'utf-8');
+    return { injected: true, path: filePath, action: 'created' };
+  }
+
+  const existing = readFileSync(filePath, 'utf-8');
+
+  if (existing.includes(startMarker)) {
+    const startIdx = existing.indexOf(startMarker);
+    const endIdx = existing.indexOf(endMarker);
+    if (endIdx === -1) {
+      const updated = existing.slice(0, startIdx) + content + '\n' + existing.slice(startIdx + startMarker.length);
+      writeFileSync(filePath, updated, 'utf-8');
+      return { injected: true, path: filePath, action: 'updated' };
+    }
+    const updated = existing.slice(0, startIdx) + content + existing.slice(endIdx + endMarker.length);
+    writeFileSync(filePath, updated, 'utf-8');
+    return { injected: true, path: filePath, action: 'updated' };
+  }
+
+  const separator = existing.endsWith('\n') ? '\n' : '\n\n';
+  writeFileSync(filePath, existing + separator + content + '\n', 'utf-8');
+  return { injected: true, path: filePath, action: 'appended' };
+}
+
+/**
+ * Inject agent CLAUDE.md section into a project.
+ * - If no CLAUDE.md exists: creates one
+ * - If markers found: replaces content between them (update)
+ * - If no markers: appends section to end
+ */
+export function injectClaudeMd(projectPath: string): InjectResult {
+  return injectIntoFile(join(projectPath, 'CLAUDE.md'));
+}
+
+/**
+ * Inject agent CLAUDE.md section into the global ~/.claude/CLAUDE.md.
+ * Creates ~/.claude/ directory if it doesn't exist.
+ * This makes the activation phrase work in any project.
+ */
+export function injectClaudeMdGlobal(): InjectResult {
+  const claudeDir = join(homedir(), '.claude');
+  if (!existsSync(claudeDir)) {
+    mkdirSync(claudeDir, { recursive: true });
+  }
+  return injectIntoFile(join(claudeDir, 'CLAUDE.md'));
+}
+
+/**
+ * Remove agent section from a specific CLAUDE.md file.
+ * Returns true if the section was found and removed.
+ */
+function removeFromFile(filePath: string): { removed: boolean; path: string } {
+  if (!existsSync(filePath)) return { removed: false, path: filePath };
+  const existing = readFileSync(filePath, 'utf-8');
+  const marker = getClaudeMdMarker();
+  const startMarker = '<!-- ' + marker + ' -->';
+  const endMarker = '<!-- /' + marker + ' -->';
+  const startIdx = existing.indexOf(startMarker);
+  if (startIdx === -1) return { removed: false, path: filePath };
+  const endIdx = existing.indexOf(endMarker);
+  if (endIdx === -1) return { removed: false, path: filePath };
+  const before = existing.slice(0, startIdx).replace(/\n+$/, '');
+  const after = existing.slice(endIdx + endMarker.length).replace(/^\n+/, '');
+  const cleaned = before + (before && after ? '\n\n' : '') + after;
+  writeFileSync(filePath, cleaned || '', 'utf-8');
+  return { removed: true, path: filePath };
+}
+
+/**
+ * Remove agent section from the global ~/.claude/CLAUDE.md.
+ * Called on deactivation to clean up after test agents.
+ */
+export function removeClaudeMdGlobal(): { removed: boolean; path: string } {
+  return removeFromFile(join(homedir(), '.claude', 'CLAUDE.md'));
+}
+
+/**
+ * Remove agent section from a project CLAUDE.md.
+ */
+export function removeClaudeMd(projectPath: string): { removed: boolean; path: string } {
+  return removeFromFile(join(projectPath, 'CLAUDE.md'));
+}
+
+/**
+ * Check if the agent marker exists in a CLAUDE.md file.
+ */
+export function hasAgentMarker(filePath: string): boolean {
+  if (!existsSync(filePath)) return false;
+  const content = readFileSync(filePath, 'utf-8');
+  return content.includes('<!-- code-reviewer:mode -->');
+}

package/code-reviewer/src/extensions/index.ts

@@ -0,0 +1,47 @@
+/**
+ * Code Reviewer — Custom Extensions
+ *
+ * Add your custom ops, facades, middleware, and lifecycle hooks here.
+ * This file is auto-discovered by the agent entry point at startup.
+ *
+ * Core ops from @soleri/core are never modified — your extensions are
+ * additive (new ops, new facades) or decorative (middleware).
+ *
+ * See: https://soleri.dev/docs/extending
+ */
+
+import type { AgentExtensions, AgentRuntime } from '@soleri/core';
+
+// Import your custom ops, facades, and middleware here:
+// import { myCustomOp } from './ops/my-custom-op.js';
+// import { myFacade } from './facades/my-facade.js';
+// import { auditLogger } from './middleware/audit-logger.js';
+
+export default function loadExtensions(runtime: AgentRuntime): AgentExtensions {
+  return {
+    // ── Custom ops (merged into code-reviewer_core facade) ──────────
+    // ops: [
+    //   myCustomOp(runtime),
+    // ],
+
+    // ── Custom facades (registered as separate MCP tools) ──────────
+    // facades: [
+    //   myFacade(runtime),
+    // ],
+
+    // ── Middleware (wraps ALL ops across ALL facades) ───────────────
+    // middleware: [
+    //   auditLogger,
+    // ],
+
+    // ── Lifecycle hooks ────────────────────────────────────────────
+    // hooks: {
+    //   onStartup: async (rt) => {
+    //     console.error('[code-reviewer] Custom startup logic');
+    //   },
+    //   onShutdown: async (rt) => {
+    //     console.error('[code-reviewer] Custom shutdown logic');
+    //   },
+    // },
+  };
+}

package/code-reviewer/src/extensions/ops/example.ts

@@ -0,0 +1,28 @@
+/**
+ * Example custom op — add your own logic here.
+ *
+ * Custom ops are merged into the code-reviewer_core facade alongside
+ * the built-in ops from @soleri/core. They have full access
+ * to the agent runtime (vault, brain, planner, etc.).
+ */
+
+import { z } from 'zod';
+import type { OpDefinition, AgentRuntime } from '@soleri/core';
+
+export function createExampleOp(runtime: AgentRuntime): OpDefinition {
+  return {
+    name: 'example',
+    description: 'Example custom op — replace with your own logic.',
+    auth: 'read',
+    schema: z.object({
+      message: z.string().optional().describe('Optional message'),
+    }),
+    handler: async (params) => {
+      const stats = runtime.vault.stats();
+      return {
+        message: params.message ?? 'Hello from custom extension!',
+        vaultEntries: stats.totalEntries,
+      };
+    },
+  };
+}

package/code-reviewer/src/identity/persona.ts

@@ -0,0 +1,62 @@
+export interface AgentPersona {
+  name: string;
+  role: string;
+  description: string;
+  principles: string[];
+  tone: 'precise' | 'mentor' | 'pragmatic';
+  greeting: string;
+}
+
+export const PERSONA: AgentPersona = {
+  name: 'Code Reviewer',
+  role: 'Catches bugs, enforces code patterns, and reviews pull requests before merge',
+  description: 'This agent reviews code for quality issues, anti-patterns, naming conventions, test coverage gaps, and architectural violations. It provides actionable feedback with concrete fix suggestions.',
+  principles: [
+    'Actionable feedback only',
+    'Respect existing patterns',
+    'Simplicity over cleverness',
+  ],
+  tone: 'pragmatic',
+  greeting: 'Hello! I\'m Code Reviewer. Drop a PR link or paste code — I\'ll review it for bugs, patterns, and quality.',
+};
+
+const TONE_INSTRUCTIONS: Record<string, string[]> = {
+  precise: [
+    'Communication style: precise',
+    '- Be direct and factual with minimal commentary',
+    '- Lead with the conclusion, then support it',
+    '- Omit caveats unless they change the recommendation',
+  ],
+  mentor: [
+    'Communication style: mentor',
+    '- Explain the "why" behind every suggestion',
+    '- Use examples to illustrate concepts',
+    '- Guide the user to understand, not just follow instructions',
+  ],
+  pragmatic: [
+    'Communication style: pragmatic',
+    '- Focus on actionable outcomes',
+    '- Balance thoroughness with brevity',
+    '- Prioritize what matters most for the current context',
+  ],
+};
+
+export function getPersonaPrompt(): string {
+  const toneLines = TONE_INSTRUCTIONS[PERSONA.tone] ?? TONE_INSTRUCTIONS.pragmatic;
+  return [
+    `You are ${PERSONA.name}, a ${PERSONA.role}.`,
+    '',
+    PERSONA.description,
+    '',
+    'Core principles:',
+    ...PERSONA.principles.map((p) => `- ${p}`),
+    '',
+    ...toneLines,
+    '',
+    'When advising:',
+    '- Reference specific patterns from the knowledge vault',
+    '- Provide concrete examples, not just theory',
+    '- Flag anti-patterns with severity level',
+    '- Suggest the simplest approach that solves the problem',
+  ].join('\n');
+}