@automagik/genie 4.260331.5 → 4.260331.7

package/src/lib/agent-sync.ts

@@ -3,13 +3,12 @@
  *
  * Scans {workspace}/agents/ for directories containing AGENTS.md (the discovery marker).
  * For each found agent, reads the git remote to derive repo_path, then registers or
- * updates the entry in the app_store.
+ * updates the entry in the agent directory.
  *
  * Handles lifecycle:
- *   - New agent dir → register in app_store + agents table
+ *   - New agent dir → register in agent directory
  *   - Existing agent with stale data → update
- *   - Archived agent reappearing → reactivate with full backfill
- *   - Missing agent dir → archive (never delete — preserves history)
+ *   - Missing agent dir → remove
  *
  * Used by:
  *   - `genie serve` (startup sync + file watcher)
@@ -20,13 +19,7 @@
 import { execSync } from 'node:child_process';
 import { existsSync, watch as fsWatch, readdirSync, realpathSync } from 'node:fs';
 import { join } from 'node:path';
-import {
-  getItemFromStore,
-  listItemsFromStore,
-  regenerateAgentCache,
-  registerItemInStore,
-  updateItemInStore,
-} from './agent-cache.js';
+import * as directory from './agent-directory.js';
 
 // ============================================================================
 // Types
@@ -128,98 +121,6 @@ function discoverSingleAgent(workspaceRoot: string, agentName: string): AgentInf
   };
 }
 
-// ============================================================================
-// Archive / Reactivation helpers
-// ============================================================================
-
-/** Archive an agent in both agents table and app_store. Never deletes rows. */
-async function archiveAgent(name: string): Promise<boolean> {
-  let archived = false;
-  try {
-    const { getConnection } = await import('./db.js');
-    const sql = await getConnection();
-    // Archive in agents table (set state='archived')
-    const result = await sql`
-      UPDATE agents SET state = 'archived', updated_at = now()
-      WHERE (custom_name = ${name} OR role = ${name})
-        AND (state IS NULL OR state != 'archived')
-    `;
-    if (result.count > 0) archived = true;
-  } catch {
-    // DB may not be available
-  }
-
-  // Archive in app_store (set approval_status='archived')
-  try {
-    const existing = await getItemFromStore(name).catch(() => null);
-    if (existing && existing.approval_status !== 'archived') {
-      await updateItemInStore(name, {
-        manifest: {
-          ...(existing.manifest as Record<string, unknown>),
-          archived: true,
-          archivedAt: new Date().toISOString(),
-        },
-      });
-      archived = true;
-    }
-  } catch {
-    // Best-effort
-  }
-
-  return archived;
-}
-
-/** Reactivate an archived agent with full backfill. */
-async function reactivateAgent(agent: AgentInfo): Promise<void> {
-  const orgRepo = agent.repoUrl ? extractOrgRepo(agent.repoUrl) : null;
-  const repoPath = orgRepo ?? agent.repoUrl ?? agent.dir;
-
-  // Update app_store entry — clear archived flag, refresh paths
-  const existing = await getItemFromStore(agent.name).catch(() => null);
-  if (existing) {
-    const manifest = { ...(existing.manifest as Record<string, unknown>) };
-    manifest.archived = undefined;
-    manifest.archivedAt = undefined;
-    manifest.repo = repoPath;
-    manifest.productRepo = agent.productRepo;
-    manifest.source = 'auto-sync';
-    await updateItemInStore(agent.name, {
-      installPath: agent.dir,
-      gitUrl: agent.repoUrl ?? undefined,
-      manifest,
-    });
-  }
-
-  // Reactivate in agents table
-  try {
-    const { getConnection } = await import('./db.js');
-    const sql = await getConnection();
-    await sql`
-      UPDATE agents SET state = 'idle', repo_path = ${repoPath}, updated_at = now()
-      WHERE (custom_name = ${agent.name} OR role = ${agent.name})
-        AND state = 'archived'
-    `;
-  } catch {
-    // DB may not be available
-  }
-
-  // Trigger session backfill for conversation history recovery
-  await triggerSessionBackfill(agent).catch(() => {});
-}
-
-/** Trigger session backfill for a reactivated agent. */
-async function triggerSessionBackfill(_agent: AgentInfo): Promise<void> {
-  try {
-    const { getConnection, isAvailable } = await import('./db.js');
-    if (!(await isAvailable())) return;
-    const sql = await getConnection();
-    const { startBackfill } = await import('./session-backfill.js');
-    await startBackfill(sql);
-  } catch {
-    // Best-effort — backfill may not be ready
-  }
-}
-
 // ============================================================================
 // Sync
 // ============================================================================
@@ -227,9 +128,8 @@ async function triggerSessionBackfill(_agent: AgentInfo): Promise<void> {
 /**
  * Sync all agents from {workspaceRoot}/agents/ into the directory.
  * - New agents → registered
- * - Existing agents with stale repo_path → updated
- * - Archived agents reappearing → reactivated with backfill
- * - Agents in store whose dirs are gone → archived
+ * - Existing agents with stale data → updated
+ * - Agents whose dirs are gone → removed
  *
  * Idempotent — safe to run repeatedly.
  */
@@ -249,15 +149,8 @@ export async function syncAgentDirectory(workspaceRoot: string): Promise<SyncRes
     }
   }
 
-  // Archive agents in store whose dirs no longer exist
-  await archiveMissingAgents(workspaceRoot, discoveredNames, result);
-
-  // Regenerate cache after mutations
-  const hasMutations =
-    result.registered.length + result.updated.length + result.archived.length + result.reactivated.length;
-  if (hasMutations > 0) {
-    await regenerateAgentCache().catch(() => {});
-  }
+  // Remove agents whose dirs no longer exist
+  await removeMissingAgents(discoveredNames, result);
 
   return result;
 }
@@ -267,58 +160,30 @@ export function printSyncResult(result: SyncResult): void {
   if (result.registered.length > 0) console.log(`  Registered: ${result.registered.join(', ')}`);
   if (result.updated.length > 0) console.log(`  Updated: ${result.updated.join(', ')}`);
   if (result.reactivated.length > 0) console.log(`  Reactivated: ${result.reactivated.join(', ')}`);
-  if (result.archived.length > 0) console.log(`  Archived: ${result.archived.join(', ')}`);
+  if (result.archived.length > 0) console.log(`  Removed: ${result.archived.join(', ')}`);
   if (result.unchanged.length > 0) console.log(`  Unchanged: ${result.unchanged.join(', ')}`);
   for (const err of result.errors) {
     console.error(`  Error (${err.name}): ${err.error}`);
   }
   const total = result.registered.length + result.updated.length + result.unchanged.length + result.reactivated.length;
-  console.log(`\nSync complete: ${total} active agent(s), ${result.archived.length} archived.`);
+  console.log(`\nSync complete: ${total} active agent(s), ${result.archived.length} removed.`);
 }
 
-/** Archive app_store agents whose directories no longer exist on disk. */
-async function archiveMissingAgents(
-  workspaceRoot: string,
-  discoveredNames: Set<string>,
-  result: SyncResult,
-): Promise<void> {
+/** Remove directory entries whose agent dirs no longer exist on disk. */
+async function removeMissingAgents(discoveredNames: Set<string>, result: SyncResult): Promise<void> {
   try {
-    const storeItems = await listItemsFromStore('agent');
-    const agentsDir = join(workspaceRoot, 'agents');
-
-    for (const item of storeItems) {
-      if (discoveredNames.has(item.name)) continue;
-      const manifest = (item.manifest ?? {}) as Record<string, unknown>;
-      if (manifest.archived) continue; // already archived
-      if (manifest.source !== 'auto-sync') continue; // only archive auto-synced agents
-
-      // Verify the agent was from this workspace
-      if (item.install_path && !item.install_path.startsWith(agentsDir)) continue;
+    const entries = await directory.ls();
+    for (const entry of entries) {
+      if (discoveredNames.has(entry.name)) continue;
+      if (entry.scope === 'built-in') continue;
+      if (!entry.dir || !entry.dir.includes('/agents/')) continue; // only remove auto-synced
 
-      const archived = await archiveAgent(item.name);
-      if (archived) result.archived.push(item.name);
+      const removed = await directory.rm(entry.name);
+      if (removed) result.archived.push(entry.name);
     }
   } catch {
-    // Best-effort — don't block sync on archive failures
-  }
-}
-
-/** Sync a single agent by name from the workspace (used by file watcher). */
-async function syncSingleAgentByName(workspaceRoot: string, agentName: string): Promise<string> {
-  const agent = discoverSingleAgent(workspaceRoot, agentName);
-  if (!agent) return 'not-found';
-
-  const result: SyncResult = { registered: [], updated: [], unchanged: [], archived: [], reactivated: [], errors: [] };
-  await syncSingleAgent(agent, result);
-
-  if (result.registered.length > 0 || result.updated.length > 0 || result.reactivated.length > 0) {
-    await regenerateAgentCache().catch(() => {});
+    // Best-effort
   }
-
-  if (result.reactivated.length > 0) return 'reactivated';
-  if (result.registered.length > 0) return 'registered';
-  if (result.updated.length > 0) return 'updated';
-  return 'unchanged';
 }
 
 /** Core sync logic for a single agent. */
@@ -326,39 +191,26 @@ async function syncSingleAgent(agent: AgentInfo, result: SyncResult): Promise<vo
   const orgRepo = agent.repoUrl ? extractOrgRepo(agent.repoUrl) : null;
   const repoPath = orgRepo ?? agent.repoUrl ?? agent.dir;
 
-  const existing = await getItemFromStore(agent.name).catch(() => null);
+  const existing = await directory.get(agent.name);
 
   if (!existing) {
-    await registerItemInStore({
+    await directory.add({
       name: agent.name,
-      itemType: 'agent',
-      installPath: agent.dir,
-      gitUrl: agent.repoUrl ?? undefined,
-      manifest: { promptMode: 'append', repo: repoPath, productRepo: agent.productRepo, source: 'auto-sync' },
+      dir: agent.dir,
+      repo: repoPath,
+      promptMode: 'append',
     });
     result.registered.push(agent.name);
     return;
   }
 
-  // Check if this is a reactivation (was archived)
-  const manifest = (existing.manifest ?? {}) as Record<string, unknown>;
-  if (manifest.archived) {
-    await reactivateAgent(agent);
-    result.reactivated.push(agent.name);
-    return;
-  }
-
   // Check if update needed
-  const needsUpdate =
-    (manifest.repo as string) !== repoPath ||
-    existing.install_path !== agent.dir ||
-    (agent.productRepo && manifest.productRepo !== agent.productRepo);
+  const needsUpdate = existing.repo !== repoPath || existing.dir !== agent.dir;
 
   if (needsUpdate) {
-    await updateItemInStore(agent.name, {
-      installPath: agent.dir,
-      gitUrl: agent.repoUrl ?? undefined,
-      manifest: { ...manifest, repo: repoPath, productRepo: agent.productRepo, source: 'auto-sync' },
+    await directory.edit(agent.name, {
+      dir: agent.dir,
+      repo: repoPath,
     });
     result.updated.push(agent.name);
   } else {
@@ -374,21 +226,17 @@ interface AgentWatcher {
   close: () => void;
 }
 
-/** Process a single watched agent change — register, update, archive, or reactivate. */
-async function processWatchedAgent(workspaceRoot: string, agentsDir: string, name: string): Promise<string | null> {
-  const agentDir = join(agentsDir, name);
-  if (existsSync(agentDir) && existsSync(join(agentDir, 'AGENTS.md'))) {
-    const action = await syncSingleAgentByName(workspaceRoot, name);
-    return action !== 'unchanged' && action !== 'not-found' ? action : null;
-  }
-  if (!existsSync(agentDir)) {
-    const archived = await archiveAgent(name);
-    if (archived) {
-      await regenerateAgentCache().catch(() => {});
-      return 'archived';
-    }
-  }
-  return null;
+/** Sync a single agent by name from the workspace (used by file watcher). */
+async function syncSingleAgentByName(workspaceRoot: string, agentName: string): Promise<string> {
+  const agent = discoverSingleAgent(workspaceRoot, agentName);
+  if (!agent) return 'not-found';
+
+  const result: SyncResult = { registered: [], updated: [], unchanged: [], archived: [], reactivated: [], errors: [] };
+  await syncSingleAgent(agent, result);
+
+  if (result.registered.length > 0) return 'registered';
+  if (result.updated.length > 0) return 'updated';
+  return 'unchanged';
 }
 
 /**
@@ -396,8 +244,7 @@ async function processWatchedAgent(workspaceRoot: string, agentsDir: string, nam
  * Debounces changes with a 2s window.
  *
  * - New directory with AGENTS.md → auto-register
- * - Archived agent reappearing → reactivate with backfill
- * - Removed directory → archive (never delete)
+ * - Removed directory → remove from directory
  */
 export function watchAgentDirectory(
   workspaceRoot: string,
@@ -440,3 +287,17 @@ export function watchAgentDirectory(
     },
   };
 }
+
+/** Process a single watched agent change. */
+async function processWatchedAgent(workspaceRoot: string, agentsDir: string, name: string): Promise<string | null> {
+  const agentDir = join(agentsDir, name);
+  if (existsSync(agentDir) && existsSync(join(agentDir, 'AGENTS.md'))) {
+    const action = await syncSingleAgentByName(workspaceRoot, name);
+    return action !== 'unchanged' && action !== 'not-found' ? action : null;
+  }
+  if (!existsSync(agentDir)) {
+    const removed = await directory.rm(name);
+    if (removed) return 'removed';
+  }
+  return null;
+}

package/src/lib/export-format.ts

@@ -18,16 +18,7 @@ export interface ExportDocument {
   data: Record<string, unknown[]>;
 }
 
-export type ExportGroup =
-  | 'boards'
-  | 'tasks'
-  | 'tags'
-  | 'projects'
-  | 'schedules'
-  | 'agents'
-  | 'apps'
-  | 'comms'
-  | 'config';
+export type ExportGroup = 'boards' | 'tasks' | 'tags' | 'projects' | 'schedules' | 'agents' | 'comms' | 'config';
 
 /** Tables belonging to each export group */
 export const GROUP_TABLES: Record<ExportGroup, string[]> = {
@@ -37,7 +28,6 @@ export const GROUP_TABLES: Record<ExportGroup, string[]> = {
   projects: ['projects'],
   schedules: ['schedules'],
   agents: ['agents', 'agent_templates', 'agent_checkpoints'],
-  apps: ['app_store', 'installed_apps', 'app_versions'],
   comms: ['conversations', 'conversation_members', 'messages', 'mailbox', 'team_chat', 'notification_preferences'],
   config: ['os_config', 'instances', 'warm_pool', 'golden_images'],
 };
@@ -49,7 +39,6 @@ export const ALL_GROUPS: ExportGroup[] = [
   'projects',
   'schedules',
   'agents',
-  'apps',
   'comms',
   'config',
 ];

package/src/lib/import-order.ts

@@ -21,23 +21,13 @@ const IMPORT_LEVELS: string[][] = [
     'task_types',
     'notification_preferences',
     // Optional (KhalOS)
-    'app_store',
     'os_config',
     'golden_images',
     'warm_pool',
     'instances',
   ],
   // Level 1: Depend on Level 0
-  [
-    'triggers',
-    'boards',
-    'board_templates',
-    'agents',
-    'conversations',
-    // Optional (KhalOS)
-    'installed_apps',
-    'app_versions',
-  ],
+  ['triggers', 'boards', 'board_templates', 'agents', 'conversations'],
   // Level 2: Depend on Level 1
   ['tasks', 'runs', 'messages', 'conversation_members', 'mailbox', 'team_chat'],
   // Level 3: Depend on Level 2

package/src/term-commands/agent/directory.ts

@@ -4,7 +4,6 @@
  */
 
 import type { Command } from 'commander';
-import { type StoreRow, listItemsFromStore, migrateAgentDirectory } from '../../lib/agent-cache.js';
 import * as directory from '../../lib/agent-directory.js';
 import { printSyncResult, syncAgentDirectory } from '../../lib/agent-sync.js';
 import { ALL_BUILTINS } from '../../lib/builtin-agents.js';
@@ -82,42 +81,8 @@ function printBuiltinAgentsTable(): void {
   console.log('');
 }
 
-function normalizeRoles(roles?: string[]): string[] | undefined {
-  if (!roles) return undefined;
-  return roles
-    .flatMap((r) => r.split(','))
-    .map((r) => r.trim())
-    .filter(Boolean);
-}
-
-async function listEntries(json?: boolean, includeBuiltins?: boolean, includeArchived?: boolean): Promise<void> {
-  await migrateAgentDirectory().catch(() => {});
-
-  let entries: directory.ScopedDirectoryEntry[];
-  try {
-    const storeItems = await listItemsFromStore('agent');
-    entries = storeItems
-      .filter((item: StoreRow) => {
-        if (includeArchived) return true;
-        const manifest = (item.manifest ?? {}) as Record<string, unknown>;
-        return !manifest.archived;
-      })
-      .map((item: StoreRow) => {
-        const manifest = (item.manifest ?? {}) as Record<string, unknown>;
-        return {
-          name: item.name,
-          dir: (item.install_path as string) ?? '',
-          repo: (manifest.repo as string) ?? '',
-          promptMode: ((manifest.promptMode as string) ?? 'append') as directory.PromptMode,
-          model: manifest.model as string | undefined,
-          roles: normalizeRoles(manifest.roles as string[] | undefined),
-          registeredAt: item.installed_at as string,
-          scope: (manifest.archived ? 'archived' : 'global') as directory.DirectoryScope,
-        };
-      });
-  } catch {
-    entries = await directory.ls();
-  }
+async function listEntries(json?: boolean, includeBuiltins?: boolean, _includeArchived?: boolean): Promise<void> {
+  const entries = await directory.ls();
 
   if (json) {
     const result: Record<string, unknown>[] = entries.map((e) => ({ ...e, builtin: false }));

package/src/term-commands/agent/index.ts

@@ -37,4 +37,10 @@ export function registerAgentCommands(program: Command): void {
   registerAgentBrief(agent);
   registerAgentLog(agent);
   registerAgentSend(agent);
+
+  agent.on('command:*', (operands: string[]) => {
+    const cmd = operands[0];
+    const available = agent.commands.map((c) => c.name()).join(', ');
+    agent.error(`Unknown agent command '${cmd}'. Available: ${available}`);
+  });
 }

package/src/term-commands/dir.ts

@@ -12,28 +12,16 @@
  * Commands:
  *   genie agent register <name>  — Register agent locally + auto-register in Omni
  *
- * Storage: Primary source is `app_store` table (item_type='agent').
- * Legacy `agents` table kept for backward compat with spawn.
- * JSON cache (~/.genie/agent-directory.json) regenerated after every mutation.
+ * Storage: agent-directory.json is the source of truth for registered agents.
  */
 
 import { resolve as resolvePath } from 'node:path';
 import type { Command } from 'commander';
-import {
-  type StoreRow,
-  listItemsFromStore,
-  migrateAgentDirectory,
-  regenerateAgentCache,
-  registerItemInStore,
-  removeItemFromStore,
-  updateItemInStore,
-} from '../lib/agent-cache.js';
 import * as directory from '../lib/agent-directory.js';
 import { printSyncResult, syncAgentDirectory } from '../lib/agent-sync.js';
 import { getActor, recordAuditEvent } from '../lib/audit.js';
 import { ALL_BUILTINS } from '../lib/builtin-agents.js';
 import { contractPath } from '../lib/genie-config.js';
-import { findOmniAgent, registerAgentInOmni, resolveOmniApiUrl } from '../lib/omni-registration.js';
 
 export function registerDirNamespace(program: Command): void {
   const dir = program.command('dir').description('Agent directory management');
@@ -66,9 +54,6 @@ export function registerDirNamespace(program: Command): void {
     .action(async (name: string, options: { global?: boolean }) => {
       try {
         const removed = await directory.rm(name, { global: options.global });
-        // Also remove from app_store
-        await removeItemFromStore(name).catch(() => {});
-        await regenerateAgentCache();
         recordAuditEvent('item', name, 'item_removed', getActor(), { type: 'agent', source: 'dir_rm' }).catch(() => {});
 
         if (removed) {
@@ -165,18 +150,6 @@ async function handleDirAdd(name: string, options: DirAddOptions): Promise<void>
     { global: options.global },
   );
 
-  // Also register in app_store (primary source of truth)
-  try {
-    await registerItemInStore({
-      name,
-      itemType: 'agent',
-      installPath: resolvedDir,
-      manifest: { promptMode, model: options.model, roles: normalizeRoles(options.roles), repo: options.repo },
-    });
-  } catch {
-    // Best-effort — legacy agents table is still the spawn path
-  }
-  await regenerateAgentCache();
   recordAuditEvent('item', name, 'item_registered', getActor(), { type: 'agent', source: 'dir_add' }).catch(() => {});
 
   const scope = options.global ? 'global' : 'project';
@@ -208,16 +181,6 @@ async function handleEdit(name: string, options: EditOptions): Promise<void> {
 
   const entry = await directory.edit(name, updates, { global: options.global });
 
-  // Also update app_store
-  try {
-    await updateItemInStore(name, {
-      installPath: updates.dir,
-      manifest: { promptMode: updates.promptMode, model: updates.model, roles: updates.roles, repo: updates.repo },
-    });
-  } catch {
-    // Best-effort
-  }
-  await regenerateAgentCache();
   recordAuditEvent('item', name, 'item_updated', getActor(), { type: 'agent', source: 'dir_edit' }).catch(() => {});
 
   const scope = options.global ? 'global' : 'project';
@@ -280,37 +243,8 @@ async function showEntry(name: string, json?: boolean): Promise<void> {
   console.log('');
 }
 
-async function listEntries(json?: boolean, includeBuiltins?: boolean, includeArchived?: boolean): Promise<void> {
-  // One-time migration from legacy JSON → DB (idempotent, best-effort)
-  await migrateAgentDirectory().catch(() => {});
-
-  // Try app_store first (primary), fall back to legacy agents table
-  let entries: directory.ScopedDirectoryEntry[];
-  try {
-    const storeItems = await listItemsFromStore('agent');
-    entries = storeItems
-      .filter((item: StoreRow) => {
-        if (includeArchived) return true;
-        const manifest = (item.manifest ?? {}) as Record<string, unknown>;
-        return !manifest.archived;
-      })
-      .map((item: StoreRow) => {
-        const manifest = (item.manifest ?? {}) as Record<string, unknown>;
-        return {
-          name: item.name,
-          dir: (item.install_path as string) ?? '',
-          repo: (manifest.repo as string) ?? '',
-          promptMode: ((manifest.promptMode as string) ?? 'append') as directory.PromptMode,
-          model: manifest.model as string | undefined,
-          roles: normalizeRoles(manifest.roles as string[] | undefined),
-          registeredAt: item.installed_at as string,
-          scope: (manifest.archived ? 'archived' : 'global') as directory.DirectoryScope,
-        };
-      });
-  } catch {
-    // Fallback to legacy
-    entries = await directory.ls();
-  }
+async function listEntries(json?: boolean, includeBuiltins?: boolean, _includeArchived?: boolean): Promise<void> {
+  const entries = await directory.ls();
 
   if (json) {
     listEntriesJson(entries, includeBuiltins);
@@ -420,94 +354,3 @@ function printBuiltinsTable(): void {
   }
   console.log('');
 }
-
-// ============================================================================
-// Agent namespace — genie agent register
-// ============================================================================
-
-interface RegisterOptions {
-  dir: string;
-  repo?: string;
-  promptMode: string;
-  model?: string;
-  roles?: string[];
-  global?: boolean;
-  skipOmni?: boolean;
-}
-
-async function handleOmniRegistration(
-  name: string,
-  options: { model?: string; roles?: string[]; global?: boolean },
-): Promise<void> {
-  const omniUrl = await resolveOmniApiUrl();
-  if (!omniUrl) return;
-
-  console.log(`\nRegistering in Omni (${omniUrl})...`);
-
-  const existingId = await findOmniAgent(name);
-  if (existingId) {
-    console.log(`  Agent already exists in Omni: ${existingId}`);
-    await directory.edit(name, { omniAgentId: existingId }, { global: options.global });
-    console.log('  Linked existing Omni agent to directory entry.');
-    return;
-  }
-
-  const omniAgentId = await registerAgentInOmni(name, {
-    model: options.model,
-    roles: options.roles,
-  });
-  if (omniAgentId) {
-    await directory.edit(name, { omniAgentId }, { global: options.global });
-    console.log(`  Omni agent created: ${omniAgentId}`);
-    console.log('  Session isolation: per-person + per-channel');
-  }
-}
-
-async function handleAgentRegister(name: string, options: RegisterOptions): Promise<void> {
-  const promptMode = validatePromptMode(options.promptMode);
-
-  const roles = normalizeRoles(options.roles);
-  const entry = await directory.add(
-    {
-      name,
-      dir: resolvePath(options.dir),
-      repo: options.repo ? resolvePath(options.repo) : undefined,
-      promptMode,
-      model: options.model,
-      roles,
-    },
-    { global: options.global },
-  );
-
-  const scope = options.global ? 'global' : 'project';
-  console.log(`Agent "${entry.name}" registered (${scope}).`);
-  printEntry(entry);
-
-  if (!options.skipOmni) {
-    await handleOmniRegistration(name, { ...options, roles });
-  }
-}
-
-export function registerAgentNamespace(program: Command): void {
-  const agent = program.command('agent').description('Agent lifecycle management');
-
-  agent
-    .command('register <name>')
-    .description('Register an agent locally and auto-register in Omni when configured')
-    .requiredOption('--dir <path>', 'Agent folder (CWD + AGENTS.md)')
-    .option('--repo <path>', 'Default git repo (overridden by team)')
-    .option('--prompt-mode <mode>', 'Prompt mode: append or system', 'append')
-    .option('--model <model>', 'Default model (sonnet, opus, codex)')
-    .option('--roles <roles...>', 'Built-in roles this agent can orchestrate')
-    .option('--global', 'Write to global directory instead of project')
-    .option('--skip-omni', 'Skip Omni auto-registration')
-    .action(async (name: string, options: RegisterOptions) => {
-      try {
-        await handleAgentRegister(name, options);
-      } catch (error) {
-        const message = error instanceof Error ? error.message : String(error);
-        console.error(`Error: ${message}`);
-        process.exit(1);
-      }
-    });
-}