@pellux/goodvibes-agent 0.1.112 → 0.1.114

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,
   };
 }

package/src/cli/service-posture.ts

@@ -186,12 +186,6 @@ export async function buildCliServicePosture(
   if (serverBackedEnabled && !config.enabled) {
     issues.push('Connected-service settings are present, but Agent service ownership is disabled by design.');
   }
-  if (config.enabled && !config.autostart) {
-    issues.push('Connected-service autostart is off.');
-  }
-  if (config.enabled && !config.restartOnFailure) {
-    issues.push('Connected-service restart-on-failure is off.');
-  }
   for (const endpoint of endpoints) {
     if (endpoint.enabled && options.probe && endpoint.reachable === false) {
       issues.push(`${endpoint.label} is enabled but not reachable on ${endpoint.binding.host}:${endpoint.binding.port}.`);
@@ -233,8 +227,7 @@ export function formatCliServicePosture(posture: CliServicePosture, json = false
     '  ownership: managed outside goodvibes-agent',
     '  Agent owns lifecycle: no',
     `  external host config present: ${yesNo(posture.config.enabled)}`,
-    `  external host autostart config: ${yesNo(posture.config.autostart)}`,
-    `  external host restart config: ${yesNo(posture.config.restartOnFailure)}`,
+    '  external host lifecycle config: ignored by Agent',
     `  legacy host switch present: ${yesNo(posture.config.daemonEnabled)}`,
     `  log: ${posture.log.path ?? 'n/a'} (${posture.log.exists ? 'present' : 'missing'})`,
     ...(posture.log.readError ? [`  log read error: ${posture.log.readError}`] : []),

package/src/cli/status.ts

@@ -99,8 +99,6 @@ function bindLine(label: string, enabled: unknown, binding: { readonly hostMode:
 export function buildCliDoctorFindings(options: CliStatusOptions): readonly CliDoctorFinding[] {
   const config = options.configManager;
   const serviceEnabled = config.get('service.enabled') === true;
-  const serviceAutostart = config.get('service.autostart') === true;
-  const restartOnFailure = config.get('service.restartOnFailure') === true;
   const daemonEnabled = config.get('danger.daemon') === true;
   const listenerEnabled = config.get('danger.httpListener') === true;
   const webEnabled = config.get('web.enabled') === true;
@@ -180,30 +178,6 @@ export function buildCliDoctorFindings(options: CliStatusOptions): readonly CliD
     });
   }
 
-  if (serviceEnabled && !serviceAutostart) {
-    findings.push({
-      id: 'runtime-autostart-disabled',
-      area: 'runtime',
-      severity: 'warning',
-      summary: 'Connected-service autostart is off.',
-      cause: 'service.enabled is true and service.autostart is false.',
-      impact: 'Connected GoodVibes services may not be available after login or reboot even though host-managed startup is selected.',
-      action: 'Configure autostart from GoodVibes TUI or the owning host; Agent will not mutate this setting.',
-    });
-  }
-
-  if (serviceEnabled && !restartOnFailure) {
-    findings.push({
-      id: 'runtime-restart-disabled',
-      area: 'runtime',
-      severity: 'warning',
-      summary: 'Connected-service restart-on-failure is off.',
-      cause: 'service.enabled is true and service.restartOnFailure is false.',
-      impact: 'A crashed connected service or listener may stay down until manually restarted.',
-      action: 'Configure restart-on-failure from GoodVibes TUI or the owning host; Agent will not mutate this setting.',
-    });
-  }
-
   if (options.service) {
     for (const issue of options.service.issues) {
       if (findings.some((finding) => finding.summary === issue)) continue;
@@ -342,8 +316,6 @@ export function renderCliStatus(options: CliStatusOptions): string {
   const config = options.configManager;
   const snapshot = buildCliStatusSnapshot(options);
   const serviceEnabled = snapshot.runtimeConnection.enabled;
-  const serviceAutostart = snapshot.runtimeConnection.autostart;
-  const restartOnFailure = snapshot.runtimeConnection.restartOnFailure;
   const controlPlaneEnabled = snapshot.runtimeEndpoints.controlPlane.enabled;
   const listenerEnabled = snapshot.runtimeEndpoints.httpListener.enabled;
   const webEnabled = snapshot.runtimeEndpoints.web.enabled;
@@ -414,8 +386,7 @@ export function renderCliStatus(options: CliStatusOptions): string {
       '',
       'Connected-Service Config Signals:',
       `  host config present: ${yesNo(serviceEnabled)}`,
-      `  host autostart: ${yesNo(serviceAutostart)}`,
-      `  host restart policy: ${yesNo(restartOnFailure)}`,
+      '  lifecycle config: external to Agent',
       '',
       'Endpoint Diagnostics:',
       bindLine('runtimeApi', controlPlaneEnabled, controlPlaneBinding),

package/src/input/agent-workspace-basic-command-editors.ts

@@ -6,6 +6,8 @@ type AgentWorkspaceFieldReader = (fieldId: string) => string;
 export type AgentWorkspaceBasicCommandEditorKind = Extract<
   AgentWorkspaceEditorKind,
   'knowledge-file' | 'knowledge-bookmarks' | 'knowledge-browser-history' | 'knowledge-connector-ingest' | 'tts-prompt' | 'image-input' | 'skill-bundle' | 'skill-discovery-import' | 'profile-template-export' | 'profile-template-import'
+  | 'persona-discovery-import'
+  | 'routine-discovery-import'
   | 'mcp-server' | 'notify-webhook' | 'notify-webhook-remove' | 'notify-webhook-test'
 >;
 
@@ -39,6 +41,8 @@ export function isAgentWorkspaceBasicCommandEditorKind(kind: AgentWorkspaceEdito
     || kind === 'tts-prompt'
     || kind === 'image-input'
     || kind === 'skill-bundle'
+    || kind === 'persona-discovery-import'
+    || kind === 'routine-discovery-import'
     || kind === 'skill-discovery-import'
     || kind === 'profile-template-export'
     || kind === 'profile-template-import'
@@ -236,6 +240,34 @@ export function createAgentWorkspaceBasicCommandEditor(kind: AgentWorkspaceBasic
       ],
     };
   }
+  if (kind === 'persona-discovery-import') {
+    return {
+      kind,
+      mode: 'create',
+      title: 'Import Discovered Persona',
+      selectedFieldIndex: 0,
+      message: 'Import one discovered persona markdown file into the Agent-local persona registry. Type yes on the final field to confirm.',
+      fields: [
+        { id: 'name', label: 'Discovered persona', value: '', required: true, multiline: false, hint: 'Name shown by /personas discover.' },
+        { id: 'use', label: 'Use now', value: 'yes', required: false, multiline: false, hint: 'yes/no.' },
+        { id: 'confirm', label: 'Confirm', value: '', required: true, multiline: false, hint: 'Type yes to run /personas import-discovered with --yes.' },
+      ],
+    };
+  }
+  if (kind === 'routine-discovery-import') {
+    return {
+      kind,
+      mode: 'create',
+      title: 'Import Discovered Routine',
+      selectedFieldIndex: 0,
+      message: 'Import one discovered routine markdown file into the Agent-local routine registry. Type yes on the final field to confirm.',
+      fields: [
+        { id: 'name', label: 'Discovered routine', value: '', required: true, multiline: false, hint: 'Name shown by /routines discover.' },
+        { id: 'enabled', label: 'Enable now', value: 'yes', required: false, multiline: false, hint: 'yes/no.' },
+        { id: 'confirm', label: 'Confirm', value: '', required: true, multiline: false, hint: 'Type yes to run /routines import-discovered with --yes.' },
+      ],
+    };
+  }
   return {
     kind,
     mode: 'create',
@@ -595,6 +627,64 @@ export function buildAgentWorkspaceBasicCommandEditorSubmission(
       },
     };
   }
+  if (editor.kind === 'persona-discovery-import') {
+    if (!isAffirmative(readField('confirm'))) {
+      return {
+        kind: 'editor',
+        editor: { ...editor, message: 'Discovered persona import not confirmed. Type yes, then press Enter.' },
+        status: 'Agent persona import not confirmed.',
+      };
+    }
+    const parts = [
+      '/personas',
+      'import-discovered',
+      quoteSlashCommandArg(readField('name')),
+    ];
+    if (isAffirmative(readField('use'))) parts.push('--use');
+    parts.push('--yes');
+    const command = parts.join(' ');
+    return {
+      kind: 'dispatch',
+      command,
+      status: 'Opening discovered persona import.',
+      actionResult: {
+        kind: 'dispatched',
+        title: 'Opening discovered persona import',
+        detail: 'The workspace handed a confirmed local persona import command to the shell-owned command router.',
+        command,
+        safety: 'safe',
+      },
+    };
+  }
+  if (editor.kind === 'routine-discovery-import') {
+    if (!isAffirmative(readField('confirm'))) {
+      return {
+        kind: 'editor',
+        editor: { ...editor, message: 'Discovered routine import not confirmed. Type yes, then press Enter.' },
+        status: 'Agent routine import not confirmed.',
+      };
+    }
+    const parts = [
+      '/routines',
+      'import-discovered',
+      quoteSlashCommandArg(readField('name')),
+    ];
+    if (isAffirmative(readField('enabled'))) parts.push('--enabled');
+    parts.push('--yes');
+    const command = parts.join(' ');
+    return {
+      kind: 'dispatch',
+      command,
+      status: 'Opening discovered routine import.',
+      actionResult: {
+        kind: 'dispatched',
+        title: 'Opening discovered routine import',
+        detail: 'The workspace handed a confirmed local routine import command to the shell-owned command router.',
+        command,
+        safety: 'safe',
+      },
+    };
+  }
   const commandParts = [
     '/agent-skills bundle create',
     '--name',

package/src/input/agent-workspace-categories.ts

@@ -158,6 +158,8 @@ export const AGENT_WORKSPACE_CATEGORIES: readonly AgentWorkspaceCategory[] = [
     actions: [
       { id: 'personas-list', label: 'List personas', detail: 'Print the full local persona library.', command: '/personas list', kind: 'command', safety: 'read-only' },
       { id: 'personas-active', label: 'Show active persona', detail: 'Inspect the active local persona applied to new turns.', command: '/personas active', kind: 'command', safety: 'read-only' },
+      { id: 'personas-discover', label: 'Discover persona files', detail: 'Scan project and global Agent persona folders for persona markdown without importing it.', command: '/personas discover', kind: 'command', safety: 'read-only' },
+      { id: 'personas-import-discovered', label: 'Import discovered persona', detail: 'Open an in-workspace form that imports one reviewed persona markdown file into the Agent-local persona registry after typed confirmation.', editorKind: 'persona-discovery-import', kind: 'editor', safety: 'safe' },
       { id: 'personas-prev', label: 'Previous persona', detail: 'Move the local persona selection up without changing active state.', localKind: 'persona', selectionDelta: -1, kind: 'local-selection', safety: 'safe' },
       { id: 'personas-next', label: 'Next persona', detail: 'Move the local persona selection down without changing active state.', localKind: 'persona', selectionDelta: 1, kind: 'local-selection', safety: 'safe' },
       { id: 'personas-create', label: 'Create persona', detail: 'Open an in-workspace form for a local persona that writes Agent-local state only.', editorKind: 'persona', kind: 'editor', safety: 'safe' },
@@ -200,6 +202,8 @@ export const AGENT_WORKSPACE_CATEGORIES: readonly AgentWorkspaceCategory[] = [
     actions: [
       { id: 'routines-list', label: 'List routines', detail: 'Print the full local Agent routine library.', command: '/routines list', kind: 'command', safety: 'read-only' },
       { id: 'routines-enabled', label: 'Enabled routines', detail: 'Show routines available for direct use.', command: '/routines enabled', kind: 'command', safety: 'read-only' },
+      { id: 'routines-discover', label: 'Discover routine files', detail: 'Scan project and global Agent routine folders for routine markdown without importing it.', command: '/routines discover', kind: 'command', safety: 'read-only' },
+      { id: 'routines-import-discovered', label: 'Import discovered routine', detail: 'Open an in-workspace form that imports one reviewed routine markdown file into the Agent-local routine registry after typed confirmation.', editorKind: 'routine-discovery-import', kind: 'editor', safety: 'safe' },
       { id: 'routines-prev', label: 'Previous routine', detail: 'Move the local routine selection up without changing enabled state.', localKind: 'routine', selectionDelta: -1, kind: 'local-selection', safety: 'safe' },
       { id: 'routines-next', label: 'Next routine', detail: 'Move the local routine selection down without changing enabled state.', localKind: 'routine', selectionDelta: 1, kind: 'local-selection', safety: 'safe' },
       { id: 'routines-create', label: 'Create routine', detail: 'Open an in-workspace form for a repeatable local workflow that writes Agent-local state only.', editorKind: 'routine', kind: 'editor', safety: 'safe' },

package/src/input/agent-workspace-command-editor.ts

@@ -24,6 +24,8 @@ type AgentWorkspaceCommandEditorKind = Extract<
   | 'tts-prompt'
   | 'image-input'
   | 'skill-bundle'
+  | 'persona-discovery-import'
+  | 'routine-discovery-import'
   | 'skill-discovery-import'
   | 'profile-template-export'
   | 'profile-template-import'

package/src/input/agent-workspace-types.ts

@@ -26,6 +26,8 @@ export type AgentWorkspaceEditorKind =
   | 'tts-prompt'
   | 'image-input'
   | 'skill-bundle'
+  | 'persona-discovery-import'
+  | 'routine-discovery-import'
   | 'skill-discovery-import'
   | 'profile-template-export'
   | 'profile-template-import'

package/src/input/commands/personas-runtime.ts

@@ -1,3 +1,4 @@
+import { discoverPersonas, type DiscoveredPersonaRecord } from '../../agent/persona-discovery.ts';
 import { AgentPersonaRegistry, type AgentPersonaRecord } from '../../agent/persona-registry.ts';
 import type { CommandContext, CommandRegistry } from '../command-registry.ts';
 import { requireShellPaths } from './runtime-services.ts';
@@ -82,6 +83,82 @@ function renderPersona(persona: AgentPersonaRecord, activePersonaId: string | nu
   ].filter(Boolean).join('\n');
 }
 
+function summarizeDiscoveredPersona(persona: DiscoveredPersonaRecord): string {
+  const description = persona.description ? ` - ${persona.description}` : '';
+  return `  ${persona.name}  ${persona.origin}${description}\n    path: ${persona.path}`;
+}
+
+function renderDiscoveredPersonas(personas: readonly DiscoveredPersonaRecord[]): string {
+  if (personas.length === 0) {
+    return [
+      'Discovered Agent persona files',
+      '  No persona markdown files found in project/global 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: /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 frontmatterList(persona: DiscoveredPersonaRecord, key: string): readonly string[] {
+  const value = persona.frontmatter[key];
+  if (!value) return [];
+  return splitList(value);
+}
+
+async function importDiscoveredPersona(args: readonly string[], ctx: CommandContext, personaRegistry: AgentPersonaRegistry): Promise<void> {
+  const parsed = parsePersonaArgs(args);
+  const name = parsed.rest.join(' ').trim();
+  if (!name) {
+    ctx.print('Usage: /personas import-discovered <name> [--use] --yes');
+    return;
+  }
+  const discovered = findDiscoveredPersona(await discoverPersonas(requireShellPaths(ctx)), name);
+  if (!discovered) {
+    ctx.print(`Unknown discovered Agent persona: ${name}\nRun /personas discover to inspect available persona files.`);
+    return;
+  }
+  if (!parsed.yes) {
+    ctx.print([
+      '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'));
+    return;
+  }
+  const persona = personaRegistry.create({
+    name: discovered.name,
+    description: discovered.description || `Imported persona from ${discovered.origin} markdown file.`,
+    body: discovered.body,
+    tags: frontmatterList(discovered, 'tags'),
+    triggers: frontmatterList(discovered, 'triggers'),
+    source: 'imported',
+    provenance: `discovered:${discovered.origin}:${discovered.path}`,
+  });
+  if (parsed.flags.get('use') === 'true') personaRegistry.setActive(persona.id);
+  ctx.print(`Imported Agent persona ${persona.id}: ${persona.name}${parsed.flags.get('use') === 'true' ? ' (active)' : ''}`);
+}
+
 function requiredFlag(flags: ReadonlyMap<string, string>, key: string): string {
   const value = flags.get(key)?.trim();
   if (!value) throw new Error(`Missing --${key}.`);
@@ -97,7 +174,7 @@ export function registerPersonasRuntimeCommands(registry: CommandRegistry): void
     name: 'personas',
     aliases: ['persona'],
     description: 'Manage local GoodVibes Agent personas',
-    usage: '[list|search <query>|show <id>|create --name <name> --description <summary> --body <instructions>|update <id> [--name ...] [--description ...] [--body ...]|use <id>|active|clear|review <id>|stale <id> <reason...>|delete <id> --yes]',
+    usage: '[list|discover|import-discovered <name> --yes|search <query>|show <id>|create --name <name> --description <summary> --body <instructions>|update <id> [--name ...] [--description ...] [--body ...]|use <id>|active|clear|review <id>|stale <id> <reason...>|delete <id> --yes]',
     async handler(args, ctx) {
       const sub = (args[0] ?? 'list').toLowerCase();
       const registryStore = registryFromContext(ctx);
@@ -106,6 +183,14 @@ export function registerPersonasRuntimeCommands(registry: CommandRegistry): void
           ctx.print(renderList('Agent Personas', registryStore, registryStore.list()));
           return;
         }
+        if (sub === 'discover' || sub === 'discovered') {
+          ctx.print(renderDiscoveredPersonas(await discoverPersonas(requireShellPaths(ctx))));
+          return;
+        }
+        if (sub === 'import-discovered' || sub === 'import-persona') {
+          await importDiscoveredPersona(args.slice(1), ctx, registryStore);
+          return;
+        }
         if (sub === 'search') {
           const query = args.slice(1).join(' ').trim();
           ctx.print(renderList(query ? `Agent Personas matching "${query}"` : 'Agent Personas', registryStore, registryStore.search(query)));
@@ -210,7 +295,7 @@ export function registerPersonasRuntimeCommands(registry: CommandRegistry): void
           ctx.print(`Deleted Agent persona ${removed.id}: ${removed.name}`);
           return;
         }
-        ctx.print('Usage: /personas [list|search <query>|show <id>|create|update|use|active|clear|review|stale|delete]');
+        ctx.print('Usage: /personas [list|discover|import-discovered|search <query>|show <id>|create|update|use|active|clear|review|stale|delete]');
       } catch (error) {
         printError(ctx, error);
       }