@pellux/goodvibes-agent 0.1.113 → 0.1.114

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pellux/goodvibes-agent",
-  "version": "0.1.113",
+  "version": "0.1.114",
   "private": false,
   "description": "GoodVibes personal operator assistant TUI with a proactive Agent product brain, isolated Agent Knowledge, local profiles, routines, skills, personas, and explicit build delegation.",
   "type": "module",

package/src/agent/persona-discovery.ts

@@ -0,0 +1,117 @@
+import { promises as fsPromises } from 'node:fs';
+import { join } from 'node:path';
+import type { ShellPathService } from '@/runtime/index.ts';
+import { GOODVIBES_AGENT_SURFACE_ROOT } from '../config/surface.ts';
+
+export type PersonaOrigin = 'project-local' | 'global' | 'custom';
+
+export interface DiscoveredPersonaRecord {
+  readonly name: string;
+  readonly description: string;
+  readonly path: string;
+  readonly origin: PersonaOrigin;
+  readonly body: string;
+  readonly frontmatter: Record<string, string>;
+}
+
+const DIRECTORY_MARKERS: readonly string[] = ['PERSONA.md', 'persona.md', 'AGENT.md', 'agent.md'];
+
+function parseFrontmatter(content: string): Record<string, string> {
+  const match = content.match(/^---\n([\s\S]*?)\n---/);
+  if (!match) return {};
+  const result: Record<string, string> = {};
+  for (const line of match[1].split('\n')) {
+    const [key, ...rest] = line.split(':');
+    if (key && rest.length > 0) {
+      result[key.trim()] = rest.join(':').trim();
+    }
+  }
+  return result;
+}
+
+function getPersonaDirectories(cwd: string, homeDir: string): Array<{ root: string; origin: PersonaOrigin }> {
+  return [
+    { root: join(cwd, '.goodvibes', 'personas'), origin: 'project-local' },
+    { root: join(cwd, '.goodvibes', GOODVIBES_AGENT_SURFACE_ROOT, 'personas'), origin: 'project-local' },
+    { root: join(cwd, '.goodvibes', 'agents'), origin: 'project-local' },
+    { root: join(homeDir, '.goodvibes', 'personas'), origin: 'global' },
+    { root: join(homeDir, '.goodvibes', GOODVIBES_AGENT_SURFACE_ROOT, 'personas'), origin: 'global' },
+    { root: join(homeDir, '.goodvibes', 'agents'), origin: 'global' },
+  ];
+}
+
+async function readPersonaFile(path: string, origin: PersonaOrigin): Promise<DiscoveredPersonaRecord | null> {
+  let content = '';
+  try {
+    content = await fsPromises.readFile(path, 'utf-8');
+  } catch {
+    return null;
+  }
+
+  const frontmatter = parseFrontmatter(content);
+  const markdownBody = content.replace(/^---\n[\s\S]*?\n---\n?/, '').trim();
+  const body = (frontmatter.system_prompt ?? markdownBody).trim();
+  if (!body) return null;
+  const name = frontmatter.name ?? path.split(/[\\/]/).pop()?.replace(/\.md$/i, '') ?? 'persona';
+  const description = frontmatter.description ?? frontmatter.summary ?? frontmatter.title ?? '';
+
+  return {
+    name,
+    description,
+    path,
+    origin,
+    body,
+    frontmatter,
+  };
+}
+
+async function scanPersonaDirectory(root: string, origin: PersonaOrigin): Promise<DiscoveredPersonaRecord[]> {
+  let entries: string[] = [];
+  try {
+    entries = await fsPromises.readdir(root);
+  } catch {
+    return [];
+  }
+
+  const records: DiscoveredPersonaRecord[] = [];
+  for (const entry of entries.sort((a, b) => a.localeCompare(b))) {
+    if (entry.endsWith('.md')) {
+      const record = await readPersonaFile(join(root, entry), origin);
+      if (record) records.push(record);
+      continue;
+    }
+
+    for (const marker of DIRECTORY_MARKERS) {
+      const record = await readPersonaFile(join(root, entry, marker), origin);
+      if (record) {
+        records.push(record);
+        break;
+      }
+    }
+  }
+
+  return records;
+}
+
+export async function discoverPersonas(shellPaths: Pick<ShellPathService, 'workingDirectory' | 'homeDirectory'>): Promise<DiscoveredPersonaRecord[]> {
+  const seen = new Set<string>();
+  const records: DiscoveredPersonaRecord[] = [];
+
+  for (const { root, origin } of getPersonaDirectories(shellPaths.workingDirectory, shellPaths.homeDirectory)) {
+    for (const record of await scanPersonaDirectory(root, origin)) {
+      const key = record.name.toLowerCase();
+      if (seen.has(key)) continue;
+      seen.add(key);
+      records.push(record);
+    }
+  }
+
+  return records.sort((a, b) => {
+    const originRank = a.origin === b.origin
+      ? 0
+      : a.origin === 'project-local'
+        ? -1
+        : 1;
+    return originRank || a.name.localeCompare(b.name);
+  });
+}

package/src/agent/routine-discovery.ts

@@ -0,0 +1,115 @@
+import { promises as fsPromises } from 'node:fs';
+import { join } from 'node:path';
+import type { ShellPathService } from '@/runtime/index.ts';
+import { GOODVIBES_AGENT_SURFACE_ROOT } from '../config/surface.ts';
+
+export type RoutineOrigin = 'project-local' | 'global' | 'custom';
+
+export interface DiscoveredRoutineRecord {
+  readonly name: string;
+  readonly description: string;
+  readonly path: string;
+  readonly origin: RoutineOrigin;
+  readonly steps: string;
+  readonly frontmatter: Record<string, string>;
+}
+
+const DIRECTORY_MARKERS: readonly string[] = ['ROUTINE.md', 'routine.md'];
+
+function parseFrontmatter(content: string): Record<string, string> {
+  const match = content.match(/^---\n([\s\S]*?)\n---/);
+  if (!match) return {};
+  const result: Record<string, string> = {};
+  for (const line of match[1].split('\n')) {
+    const [key, ...rest] = line.split(':');
+    if (key && rest.length > 0) {
+      result[key.trim()] = rest.join(':').trim();
+    }
+  }
+  return result;
+}
+
+function getRoutineDirectories(cwd: string, homeDir: string): Array<{ root: string; origin: RoutineOrigin }> {
+  return [
+    { root: join(cwd, '.goodvibes', 'routines'), origin: 'project-local' },
+    { root: join(cwd, '.goodvibes', GOODVIBES_AGENT_SURFACE_ROOT, 'routines'), origin: 'project-local' },
+    { root: join(homeDir, '.goodvibes', 'routines'), origin: 'global' },
+    { root: join(homeDir, '.goodvibes', GOODVIBES_AGENT_SURFACE_ROOT, 'routines'), origin: 'global' },
+  ];
+}
+
+async function readRoutineFile(path: string, origin: RoutineOrigin): Promise<DiscoveredRoutineRecord | null> {
+  let content = '';
+  try {
+    content = await fsPromises.readFile(path, 'utf-8');
+  } catch {
+    return null;
+  }
+
+  const frontmatter = parseFrontmatter(content);
+  const markdownBody = content.replace(/^---\n[\s\S]*?\n---\n?/, '').trim();
+  const steps = (frontmatter.steps ?? markdownBody).trim();
+  if (!steps) return null;
+  const name = frontmatter.name ?? path.split(/[\\/]/).pop()?.replace(/\.md$/i, '') ?? 'routine';
+  const description = frontmatter.description ?? frontmatter.summary ?? frontmatter.title ?? '';
+
+  return {
+    name,
+    description,
+    path,
+    origin,
+    steps,
+    frontmatter,
+  };
+}
+
+async function scanRoutineDirectory(root: string, origin: RoutineOrigin): Promise<DiscoveredRoutineRecord[]> {
+  let entries: string[] = [];
+  try {
+    entries = await fsPromises.readdir(root);
+  } catch {
+    return [];
+  }
+
+  const records: DiscoveredRoutineRecord[] = [];
+  for (const entry of entries.sort((a, b) => a.localeCompare(b))) {
+    if (entry.endsWith('.md')) {
+      const record = await readRoutineFile(join(root, entry), origin);
+      if (record) records.push(record);
+      continue;
+    }
+
+    for (const marker of DIRECTORY_MARKERS) {
+      const record = await readRoutineFile(join(root, entry, marker), origin);
+      if (record) {
+        records.push(record);
+        break;
+      }
+    }
+  }
+
+  return records;
+}
+
+export async function discoverRoutines(shellPaths: Pick<ShellPathService, 'workingDirectory' | 'homeDirectory'>): Promise<DiscoveredRoutineRecord[]> {
+  const seen = new Set<string>();
+  const records: DiscoveredRoutineRecord[] = [];
+
+  for (const { root, origin } of getRoutineDirectories(shellPaths.workingDirectory, shellPaths.homeDirectory)) {
+    for (const record of await scanRoutineDirectory(root, origin)) {
+      const key = record.name.toLowerCase();
+      if (seen.has(key)) continue;
+      seen.add(key);
+      records.push(record);
+    }
+  }
+
+  return records.sort((a, b) => {
+    const originRank = a.origin === b.origin
+      ? 0
+      : a.origin === 'project-local'
+        ? -1
+        : 1;
+    return originRank || a.name.localeCompare(b.name);
+  });
+}

package/src/cli/help.ts

@@ -165,6 +165,8 @@ const COMMAND_HELP: Record<string, CommandHelp> = {
     usage: [
       'personas list',
       'personas active',
+      'personas discover',
+      'personas import-discovered <name> [--use] --yes',
       'personas search <query>',
       'personas show <id>',
       'personas create --name <name> --description <summary> --body <instructions> [--tags a,b] [--triggers a,b] [--use]',
@@ -178,6 +180,8 @@ const COMMAND_HELP: Record<string, CommandHelp> = {
     summary: 'Manage Agent-local personas for the serial main conversation. Personas do not spawn worker agents.',
     examples: [
       'personas list',
+      'personas discover',
+      'personas import-discovered "Travel Planner" --use --yes',
       'personas create --name "Travel Planner" --description "Plan trips" --body "Compare options before booking" --use',
       'personas review travel-planner',
       'personas delete travel-planner --yes',
@@ -243,15 +247,19 @@ const COMMAND_HELP: Record<string, CommandHelp> = {
     usage: [
       'routines list',
       'routines enabled',
+      'routines discover',
+      'routines import-discovered <name> [--enabled] --yes',
       'routines show <id>',
       'routines receipts',
       'routines reconcile',
       'routines receipt <receipt-id>',
       'routines promote <id> (--cron <expr>|--every <interval>|--at <iso-time>) [--timezone <tz>] [--name <schedule-name>] [--provider <id>] [--model <model>] [--delivery-channel <channel[:route[:label]]>|--delivery-route <route[:label]>|--delivery-webhook <url>|--delivery-link <url>] [--disabled] --yes',
     ],
-    summary: 'Inspect Agent-local routines, review local promotion receipts, reconcile receipts against live connected schedules, and explicitly promote a reviewed routine into a GoodVibes schedule. Without --yes, promote only prints the schedules.create preview.',
+    summary: 'Inspect and import Agent-local routines, review local promotion receipts, reconcile receipts against live connected schedules, and explicitly promote a reviewed routine into a GoodVibes schedule. Without --yes, promote only prints the schedules.create preview.',
     examples: [
       'routines list',
+      'routines discover',
+      'routines import-discovered "Daily Brief" --enabled --yes',
       'routines show daily-operations-sweep',
       'routines receipts',
       'routines reconcile',

package/src/cli/local-library-command.ts

@@ -1,4 +1,5 @@
 import { createShellPathService } from '@/runtime/index.ts';
+import { discoverPersonas, type DiscoveredPersonaRecord } from '../agent/persona-discovery.ts';
 import { AgentPersonaRegistry, type AgentPersonaRecord } from '../agent/persona-registry.ts';
 import { discoverSkills, type SkillRecord } from '../agent/skill-discovery.ts';
 import {
@@ -156,6 +157,50 @@ function renderPersona(persona: AgentPersonaRecord, activePersonaId: string | nu
   ].filter((line): line is string => Boolean(line)).join('\n');
 }
 
+function summarizeDiscoveredPersona(persona: DiscoveredPersonaRecord): string {
+  const description = persona.description ? ` - ${persona.description}` : '';
+  return [
+    `  ${persona.name}  ${persona.origin}${description}`,
+    `    path: ${persona.path}`,
+  ].join('\n');
+}
+
+function renderDiscoveredPersonaList(personas: readonly DiscoveredPersonaRecord[]): string {
+  if (personas.length === 0) {
+    return [
+      'Discovered Agent persona files',
+      '  No persona markdown files found in Agent persona folders.',
+      '  Search roots: .goodvibes/personas, .goodvibes/agent/personas, .goodvibes/agents, ~/.goodvibes/personas, ~/.goodvibes/agent/personas, ~/.goodvibes/agents',
+    ].join('\n');
+  }
+  return [
+    `Discovered Agent persona files (${personas.length})`,
+    ...personas.map(summarizeDiscoveredPersona),
+    '',
+    'Import one with: goodvibes-agent personas import-discovered <name> --yes',
+  ].join('\n');
+}
+
+function discoveredPersonaLookupValues(persona: DiscoveredPersonaRecord): readonly string[] {
+  const slug = persona.name.trim().toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/^-+|-+$/g, '');
+  const basename = persona.path.split(/[\\/]/).pop()?.replace(/\.md$/i, '') ?? '';
+  return [persona.name, slug, persona.path, basename]
+    .map((value) => value.trim().toLowerCase())
+    .filter(Boolean);
+}
+
+function findDiscoveredPersona(personas: readonly DiscoveredPersonaRecord[], idOrName: string): DiscoveredPersonaRecord | null {
+  const lookup = idOrName.trim().toLowerCase();
+  if (!lookup) return null;
+  return personas.find((persona) => discoveredPersonaLookupValues(persona).includes(lookup)) ?? null;
+}
+
+function discoveredPersonaFrontmatterList(persona: DiscoveredPersonaRecord, key: string): readonly string[] {
+  const value = persona.frontmatter[key];
+  if (!value) return [];
+  return value.split(',').map((entry) => entry.trim()).filter(Boolean);
+}
+
 function summarizeSkill(skill: AgentSkillRecord): string {
   const enabled = skill.enabled ? 'enabled' : 'disabled';
   const tags = skill.tags.length > 0 ? ` tags=${skill.tags.join(',')}` : '';
@@ -281,7 +326,7 @@ function renderBundle(bundle: AgentSkillBundleRecord): string {
 }
 
 function usagePersonas(): string {
-  return 'Usage: goodvibes-agent personas [list|active|search <query>|show <id>|create|update <id>|use <id>|clear|review <id>|stale <id> <reason>|delete <id> --yes]';
+  return 'Usage: goodvibes-agent personas [list|active|discover|import-discovered <name> --yes|search <query>|show <id>|create|update <id>|use <id>|clear|review <id>|stale <id> <reason>|delete <id> --yes]';
 }
 
 function usageSkills(): string {
@@ -312,6 +357,41 @@ export async function handlePersonasCommand(runtime: CliCommandRuntime): Promise
       if (!active) return failure(runtime, 'agent.personas.active_missing', 'No active Agent persona.', 1);
       return success(runtime, 'agent.personas.active', active, renderPersona(active, active.id));
     }
+    if (normalized === 'discover') {
+      const discovered = await discoverPersonas(shellPaths(runtime));
+      return success(runtime, 'agent.personas.discover', { personas: discovered }, renderDiscoveredPersonaList(discovered));
+    }
+    if (normalized === 'import-discovered' || normalized === 'import-persona') {
+      const options = parseOptions(rest);
+      const name = options.positionals.join(' ').trim();
+      if (!name) return failure(runtime, 'invalid_persona_command', 'Usage: goodvibes-agent personas import-discovered <name> [--use] --yes', 2);
+      const discovered = findDiscoveredPersona(await discoverPersonas(shellPaths(runtime)), name);
+      if (!discovered) {
+        return failure(runtime, 'persona_discovery_not_found', `Unknown discovered Agent persona: ${name}\nRun goodvibes-agent personas discover to inspect available persona files.`, 1);
+      }
+      if (!hasFlag(options, 'yes')) {
+        return success(runtime, 'agent.personas.import_discovered.preview', { persona: discovered }, [
+          'Agent persona import preview',
+          `  name: ${discovered.name}`,
+          `  origin: ${discovered.origin}`,
+          `  path: ${discovered.path}`,
+          `  description: ${discovered.description || '(none)'}`,
+          `  body characters: ${discovered.body.length}`,
+          '  next: rerun with --yes to import into the Agent-local persona registry',
+        ].join('\n'));
+      }
+      const persona = registry.create({
+        name: discovered.name,
+        description: discovered.description || `Imported persona from ${discovered.origin} markdown file.`,
+        body: discovered.body,
+        tags: discoveredPersonaFrontmatterList(discovered, 'tags'),
+        triggers: discoveredPersonaFrontmatterList(discovered, 'triggers'),
+        source: 'imported',
+        provenance: `discovered:${discovered.origin}:${discovered.path}`,
+      });
+      if (hasFlag(options, 'use')) registry.setActive(persona.id);
+      return success(runtime, 'agent.personas.import_discovered', persona, `Imported Agent persona ${persona.id}: ${persona.name}${hasFlag(options, 'use') ? ' (active)' : ''}`);
+    }
     if (normalized === 'search' || normalized === 'find') {
       const query = rest.join(' ').trim();
       const results = registry.search(query);

package/src/cli/routines-command.ts

@@ -1,4 +1,5 @@
 import { createShellPathService } from '@/runtime/index.ts';
+import { discoverRoutines, type DiscoveredRoutineRecord } from '../agent/routine-discovery.ts';
 import { AgentRoutineRegistry, type AgentRoutineRecord } from '../agent/routine-registry.ts';
 import {
   buildRoutineSchedulePreview,
@@ -44,6 +45,13 @@ function routineRegistry(runtime: CliCommandRuntime): AgentRoutineRegistry {
   }));
 }
 
+function shellPaths(runtime: CliCommandRuntime): ReturnType<typeof createShellPathService> {
+  return createShellPathService({
+    workingDirectory: runtime.workingDirectory,
+    homeDirectory: runtime.homeDirectory,
+  });
+}
+
 function routineReceiptStore(runtime: CliCommandRuntime): RoutineScheduleReceiptStore {
   return RoutineScheduleReceiptStore.fromShellPaths(createShellPathService({
     workingDirectory: runtime.workingDirectory,
@@ -51,12 +59,83 @@ function routineReceiptStore(runtime: CliCommandRuntime): RoutineScheduleReceipt
   }));
 }
 
+function splitList(value: string | undefined): readonly string[] {
+  if (!value) return [];
+  return value.split(',').map((entry) => entry.trim()).filter(Boolean);
+}
+
+function parseImportFlags(args: readonly string[]): {
+  readonly name: string;
+  readonly enabled: boolean;
+  readonly yes: boolean;
+} {
+  const positionals: string[] = [];
+  let enabled = false;
+  let yes = false;
+  for (const arg of args) {
+    if (arg === '--enabled') {
+      enabled = true;
+      continue;
+    }
+    if (arg === '--yes') {
+      yes = true;
+      continue;
+    }
+    positionals.push(arg);
+  }
+  return { name: positionals.join(' ').trim(), enabled, yes };
+}
+
 function summarizeRoutine(routine: AgentRoutineRecord): string {
   const enabled = routine.enabled ? 'enabled' : 'disabled';
   const tags = routine.tags.length > 0 ? ` tags=${routine.tags.join(',')}` : '';
   return `  ${routine.id}  ${enabled}  ${routine.reviewState}  starts=${routine.startCount}  ${routine.name} - ${routine.description}${tags}`;
 }
 
+function summarizeDiscoveredRoutine(routine: DiscoveredRoutineRecord): string {
+  const description = routine.description ? ` - ${routine.description}` : '';
+  return [
+    `  ${routine.name}  ${routine.origin}${description}`,
+    `    path: ${routine.path}`,
+  ].join('\n');
+}
+
+function renderDiscoveredRoutineList(routines: readonly DiscoveredRoutineRecord[]): string {
+  if (routines.length === 0) {
+    return [
+      'Discovered Agent routine files',
+      '  No routine markdown files found in Agent routine folders.',
+      '  Search roots: .goodvibes/routines, .goodvibes/agent/routines, ~/.goodvibes/routines, ~/.goodvibes/agent/routines',
+    ].join('\n');
+  }
+  return [
+    `Discovered Agent routine files (${routines.length})`,
+    ...routines.map(summarizeDiscoveredRoutine),
+    '',
+    'Import one with: goodvibes-agent routines import-discovered <name> --yes',
+  ].join('\n');
+}
+
+function discoveredRoutineLookupValues(routine: DiscoveredRoutineRecord): readonly string[] {
+  const slug = routine.name.trim().toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/^-+|-+$/g, '');
+  const basename = routine.path.split(/[\\/]/).pop()?.replace(/\.md$/i, '') ?? '';
+  return [routine.name, slug, routine.path, basename]
+    .map((value) => value.trim().toLowerCase())
+    .filter(Boolean);
+}
+
+function findDiscoveredRoutine(routines: readonly DiscoveredRoutineRecord[], idOrName: string): DiscoveredRoutineRecord | null {
+  const lookup = idOrName.trim().toLowerCase();
+  if (!lookup) return null;
+  return routines.find((routine) => discoveredRoutineLookupValues(routine).includes(lookup)) ?? null;
+}
+
+function discoveredRoutineFrontmatterList(routine: DiscoveredRoutineRecord, key: string): readonly string[] {
+  const value = routine.frontmatter[key];
+  if (!value) return [];
+  return splitList(value);
+}
+
 function renderRoutineList(title: string, path: string, routines: readonly AgentRoutineRecord[]): string {
   if (routines.length === 0) {
     return [
@@ -176,6 +255,82 @@ export async function handleRoutinesCommand(runtime: CliCommandRuntime): Promise
       exitCode: 0,
     };
   }
+  if (normalized === 'discover') {
+    const discovered = await discoverRoutines(shellPaths(runtime));
+    const value: RoutinesCommandSuccess<{ readonly routines: readonly DiscoveredRoutineRecord[] }> = {
+      ok: true,
+      kind: 'agent.routines.discover',
+      data: { routines: discovered },
+    };
+    return {
+      output: jsonOrText(runtime, value, renderDiscoveredRoutineList(discovered)),
+      exitCode: 0,
+    };
+  }
+  if (normalized === 'import-discovered' || normalized === 'import-routine') {
+    const parsed = parseImportFlags(rest);
+    if (!parsed.name) {
+      const failure: RoutinesCommandFailure = {
+        ok: false,
+        kind: 'invalid_routine_command',
+        error: 'Usage: goodvibes-agent routines import-discovered <name> [--enabled] --yes',
+      };
+      return {
+        output: runtime.cli.flags.outputFormat === 'json' ? JSON.stringify(failure, null, 2) : failure.error,
+        exitCode: 2,
+      };
+    }
+    const discovered = findDiscoveredRoutine(await discoverRoutines(shellPaths(runtime)), parsed.name);
+    if (!discovered) {
+      const failure: RoutinesCommandFailure = {
+        ok: false,
+        kind: 'routine_discovery_not_found',
+        error: `Unknown discovered Agent routine: ${parsed.name}\nRun goodvibes-agent routines discover to inspect available routine files.`,
+      };
+      return {
+        output: runtime.cli.flags.outputFormat === 'json' ? JSON.stringify(failure, null, 2) : failure.error,
+        exitCode: 1,
+      };
+    }
+    if (!parsed.yes) {
+      const value: RoutinesCommandSuccess<{ readonly routine: DiscoveredRoutineRecord }> = {
+        ok: true,
+        kind: 'agent.routines.import_discovered.preview',
+        data: { routine: discovered },
+      };
+      return {
+        output: jsonOrText(runtime, value, [
+          'Agent routine import preview',
+          `  name: ${discovered.name}`,
+          `  origin: ${discovered.origin}`,
+          `  path: ${discovered.path}`,
+          `  description: ${discovered.description || '(none)'}`,
+          `  steps characters: ${discovered.steps.length}`,
+          '  next: rerun with --yes to import into the Agent-local routine registry',
+        ].join('\n')),
+        exitCode: 0,
+      };
+    }
+    const routine = registry.create({
+      name: discovered.name,
+      description: discovered.description || `Imported routine from ${discovered.origin} markdown file.`,
+      steps: discovered.steps,
+      tags: discoveredRoutineFrontmatterList(discovered, 'tags'),
+      triggers: discoveredRoutineFrontmatterList(discovered, 'triggers'),
+      enabled: parsed.enabled,
+      source: 'imported',
+      provenance: `discovered:${discovered.origin}:${discovered.path}`,
+    });
+    const value: RoutinesCommandSuccess<AgentRoutineRecord> = {
+      ok: true,
+      kind: 'agent.routines.import_discovered',
+      data: routine,
+    };
+    return {
+      output: jsonOrText(runtime, value, `Imported Agent routine ${routine.id}: ${routine.name}${routine.enabled ? ' (enabled)' : ''}`),
+      exitCode: 0,
+    };
+  }
   if (normalized === 'show') {
     const id = rest[0];
     if (!id) return { output: 'Usage: goodvibes-agent routines show <id>', exitCode: 2 };
@@ -241,7 +396,7 @@ export async function handleRoutinesCommand(runtime: CliCommandRuntime): Promise
     return handleRoutinePromotion(runtime, rest);
   }
   return {
-    output: 'Usage: goodvibes-agent routines [list|enabled|show <id>|receipts|reconcile|receipt <id>|promote <id> (--cron <expr>|--every <interval>|--at <iso-time>) [--delivery-channel <channel>|--delivery-route <route>|--delivery-webhook <url>] --yes]',
+    output: 'Usage: goodvibes-agent routines [list|enabled|discover|import-discovered <name> --yes|show <id>|receipts|reconcile|receipt <id>|promote <id> (--cron <expr>|--every <interval>|--at <iso-time>) [--delivery-channel <channel>|--delivery-route <route>|--delivery-webhook <url>] --yes]',
     exitCode: 2,
   };
 }