@pellux/goodvibes-agent 0.1.113 → 0.1.116

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

@@ -4,6 +4,7 @@ import type { CommandContext } from './command-registry.ts';
 import { AgentPersonaRegistry, type AgentPersonaRecord } from '../agent/persona-registry.ts';
 import { AgentRoutineRegistry, type AgentRoutineRecord } from '../agent/routine-registry.ts';
 import { AgentSkillRegistry, type AgentSkillBundleRecord, type AgentSkillRecord } from '../agent/skill-registry.ts';
+import { summarizeAgentBehaviorDiscovery } from '../agent/behavior-discovery-summary.ts';
 import { isPromptActiveMemory } from '../agent/memory-prompt.ts';
 import { getAgentRuntimeProfilesRoot, listAgentRuntimeProfiles, listAgentRuntimeProfileTemplates } from '../agent/runtime-profile.ts';
 import { buildAgentWorkspaceChannels } from './agent-workspace-channels.ts';
@@ -233,6 +234,7 @@ export function buildAgentWorkspaceRuntimeSnapshot(context: CommandContext): Age
       return { count: 0, enabled: 0, items: [] };
     }
   })();
+  const discoveredBehavior = summarizeAgentBehaviorDiscovery(context.workspace?.shellPaths);
   const runtimeProfiles = (() => {
     try {
       return listAgentRuntimeProfiles(context.workspace?.shellPaths?.homeDirectory ?? '');
@@ -317,6 +319,9 @@ export function buildAgentWorkspaceRuntimeSnapshot(context: CommandContext): Age
     skillBundleCount: skillSnapshot.bundleCount,
     enabledSkillBundleCount: skillSnapshot.enabledBundleCount,
     activePersonaName: personaSnapshot.activeName,
+    discoveredPersonas: discoveredBehavior.personas,
+    discoveredSkills: discoveredBehavior.skills,
+    discoveredRoutines: discoveredBehavior.routines,
     readyChannelCount: channels.filter((channel) => channel.ready).length,
     voiceProviderCount: voiceProviders.length,
     mediaProviderCount: mediaProviders.length,
@@ -351,6 +356,7 @@ export function buildAgentWorkspaceRuntimeSnapshot(context: CommandContext): Age
     localPersonaCount: personaSnapshot.count,
     activePersonaName: personaSnapshot.activeName,
     localPersonas: personaSnapshot.items,
+    discoveredBehavior,
     knowledgeRoute: '/api/goodvibes-agent/knowledge',
     knowledgeIsolation: 'agent-only',
     executionPolicy: 'serial-proactive',

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

@@ -1,6 +1,7 @@
 import type { AgentWorkspaceChannelStatus } from './agent-workspace-channels.ts';
 import type { AgentWorkspaceSetupChecklistItem } from './agent-workspace-setup.ts';
 import type { AgentWorkspaceVoiceMediaReadiness } from './agent-workspace-voice-media.ts';
+import type { AgentBehaviorDiscoverySnapshot } from '../agent/behavior-discovery-summary.ts';
 
 export const AGENT_WORKSPACE_MODAL_NAME = 'agentWorkspace';
 
@@ -26,9 +27,13 @@ export type AgentWorkspaceEditorKind =
   | 'tts-prompt'
   | 'image-input'
   | 'skill-bundle'
+  | 'persona-discovery-import'
+  | 'routine-discovery-import'
   | 'skill-discovery-import'
   | 'profile-template-export'
   | 'profile-template-import'
+  | 'profile-template-from-discovered'
+  | 'profile-from-discovered'
   | 'routine-schedule'
   | 'reminder-schedule';
 
@@ -169,6 +174,7 @@ export interface AgentWorkspaceRuntimeSnapshot {
   readonly localPersonaCount: number;
   readonly activePersonaName: string;
   readonly localPersonas: readonly AgentWorkspaceLocalLibraryItem[];
+  readonly discoveredBehavior: AgentBehaviorDiscoverySnapshot;
   readonly knowledgeRoute: '/api/goodvibes-agent/knowledge';
   readonly knowledgeIsolation: 'agent-only';
   readonly executionPolicy: 'serial-proactive';

package/src/input/commands/agent-runtime-profile-runtime.ts

@@ -1,6 +1,8 @@
 import { mkdirSync } from 'node:fs';
 import { dirname } from 'node:path';
 import {
+  createAgentRuntimeProfileFromDiscovered,
+  createAgentRuntimeProfileTemplateFromDiscovered,
   createAgentRuntimeProfile,
   deleteAgentRuntimeProfile,
   exportAgentRuntimeProfileTemplate,
@@ -22,6 +24,12 @@ function parseFlag(args: readonly string[], name: string): string | undefined {
   return value && !value.startsWith('--') ? value : undefined;
 }
 
+function parseCsvFlag(args: readonly string[], name: string): readonly string[] | undefined {
+  const raw = parseFlag(args, name);
+  if (!raw) return undefined;
+  return raw.split(',').map((entry) => entry.trim()).filter(Boolean);
+}
+
 function profileLine(profile: AgentRuntimeProfileInfo): string {
   const created = profile.createdAt ? ` created=${profile.createdAt}` : '';
   const starter = profile.starterTemplateId ? ` starter=${profile.starterTemplateId}` : '';
@@ -62,6 +70,7 @@ function renderTemplates(homeDirectory: string): string {
     '  edit the JSON file',
     '  /agent-profile template import ./agent-starter.json --yes',
     '  /agent-profile create <name> --template <imported-id> --yes',
+    '  /agent-profile create-from-discovered <name> --yes',
   ].join('\n');
 }
 
@@ -108,8 +117,8 @@ export function registerAgentRuntimeProfileRuntimeCommands(registry: CommandRegi
     name: 'agent-profile',
     aliases: ['runtime-profile', 'agent-profiles'],
     description: 'Manage isolated Agent profiles and starter templates',
-    usage: '[list|templates|guide|template show|template export|template import|create|delete]',
-    handler(args, ctx) {
+    usage: '[list|templates|guide|template show|template export|template import|template from-discovered|create|create-from-discovered|delete]',
+    async handler(args, ctx) {
       const shellPaths = requireShellPaths(ctx);
       const homeDirectory = shellPaths.homeDirectory;
       const parsed = stripYesFlag(args);
@@ -175,7 +184,35 @@ export function registerAgentRuntimeProfileRuntimeCommands(registry: CommandRegi
             ctx.print(`Agent starter template imported: ${template.id}\n  source: ${template.source}\n  use: /agent-profile create <name> --template ${template.id} --yes`);
             return;
           }
-          ctx.print('Usage: /agent-profile template [show <id>|export <id> <path> --yes|import <path> --yes]');
+          if (mode === 'from-discovered' || mode === 'import-discovered') {
+            const templateId = commandArgs[2];
+            if (!templateId) {
+              ctx.print('Usage: /agent-profile template from-discovered <id> [--name <name>] [--description <summary>] [--persona <name>] [--skills all|name,name] [--routines all|name,name] [--replace] --yes');
+              return;
+            }
+            if (!parsed.yes) {
+              requireYesFlag(ctx, `create Agent starter template ${templateId} from discovered behavior`, '/agent-profile template from-discovered <id> --yes');
+              return;
+            }
+            const template = await createAgentRuntimeProfileTemplateFromDiscovered(shellPaths, {
+              id: templateId,
+              name: parseFlag(commandArgs, '--name'),
+              description: parseFlag(commandArgs, '--description'),
+              persona: parseFlag(commandArgs, '--persona'),
+              skills: parseCsvFlag(commandArgs, '--skills'),
+              routines: parseCsvFlag(commandArgs, '--routines'),
+              replace: commandArgs.includes('--replace'),
+            });
+            ctx.print([
+              `Agent starter template created from discovered behavior: ${template.id}`,
+              `  persona: ${template.personaName}`,
+              `  skills: ${template.skillNames.join(', ')}`,
+              `  routines: ${template.routineNames.join(', ')}`,
+              `  use: /agent-profile create <name> --template ${template.id} --yes`,
+            ].join('\n'));
+            return;
+          }
+          ctx.print('Usage: /agent-profile template [show <id>|export <id> <path> --yes|import <path> --yes|from-discovered <id> --yes]');
           return;
         }
 
@@ -200,6 +237,38 @@ export function registerAgentRuntimeProfileRuntimeCommands(registry: CommandRegi
           return;
         }
 
+        if (sub === 'create-from-discovered' || sub === 'create-discovered') {
+          const profileName = commandArgs[1];
+          if (!profileName) {
+            ctx.print('Usage: /agent-profile create-from-discovered <name> [--template-id <id>] [--profile-name <display>] [--description <summary>] [--persona <name>] [--skills all|name,name] [--routines all|name,name] [--replace] --yes');
+            return;
+          }
+          if (!parsed.yes) {
+            requireYesFlag(ctx, `create Agent profile ${profileName} from discovered behavior`, '/agent-profile create-from-discovered <name> --yes');
+            return;
+          }
+          const created = await createAgentRuntimeProfileFromDiscovered(shellPaths, {
+            profileName,
+            templateId: parseFlag(commandArgs, '--template-id') ?? parseFlag(commandArgs, '--starter-id'),
+            name: parseFlag(commandArgs, '--profile-name') ?? parseFlag(commandArgs, '--name'),
+            description: parseFlag(commandArgs, '--description'),
+            persona: parseFlag(commandArgs, '--persona'),
+            skills: parseCsvFlag(commandArgs, '--skills'),
+            routines: parseCsvFlag(commandArgs, '--routines'),
+            replace: commandArgs.includes('--replace'),
+          });
+          ctx.print([
+            `Agent profile created from discovered behavior: ${created.profile.id}`,
+            `  home: ${created.profile.homeDirectory}`,
+            `  starter: ${created.template.id}`,
+            `  persona: ${created.template.personaName}`,
+            `  skills: ${created.template.skillNames.join(', ')}`,
+            `  routines: ${created.template.routineNames.join(', ')}`,
+            `  launch: goodvibes-agent --agent-profile ${created.profile.id}`,
+          ].join('\n'));
+          return;
+        }
+
         if (sub === 'delete') {
           const name = commandArgs[1];
           if (!name) {
@@ -214,7 +283,7 @@ export function registerAgentRuntimeProfileRuntimeCommands(registry: CommandRegi
           return;
         }
 
-        ctx.print('Usage: /agent-profile [list|templates|guide|template show <id>|template export <id> <path> --yes|template import <path> --yes|create <name> [--template <id>] --yes|delete <name> --yes]');
+        ctx.print('Usage: /agent-profile [list|templates|guide|template show <id>|template export <id> <path> --yes|template import <path> --yes|create <name> [--template <id>] --yes|create-from-discovered <name> --yes|delete <name> --yes]');
       } catch (error) {
         ctx.print(`Error: ${error instanceof Error ? error.message : String(error)}`);
       }

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

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

@@ -1,3 +1,4 @@
+import { discoverRoutines, type DiscoveredRoutineRecord } from '../../agent/routine-discovery.ts';
 import { AgentRoutineRegistry, type AgentRoutineRecord } from '../../agent/routine-registry.ts';
 import {
   buildRoutineSchedulePreview,
@@ -111,10 +112,86 @@ function renderRoutine(routine: AgentRoutineRecord): string {
   ].filter(Boolean).join('\n');
 }
 
+function summarizeDiscoveredRoutine(routine: DiscoveredRoutineRecord): string {
+  const description = routine.description ? ` - ${routine.description}` : '';
+  return `  ${routine.name}  ${routine.origin}${description}\n    path: ${routine.path}`;
+}
+
+function renderDiscoveredRoutines(routines: readonly DiscoveredRoutineRecord[]): string {
+  if (routines.length === 0) {
+    return [
+      'Discovered Agent routine files',
+      '  No routine markdown files found in project/global 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: /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 frontmatterList(routine: DiscoveredRoutineRecord, key: string): readonly string[] {
+  const value = routine.frontmatter[key];
+  if (!value) return [];
+  return splitList(value);
+}
+
 function printError(ctx: CommandContext, error: unknown): void {
   ctx.print(`Error: ${error instanceof Error ? error.message : String(error)}`);
 }
 
+async function importDiscoveredRoutine(args: readonly string[], ctx: CommandContext, routineRegistry: AgentRoutineRegistry): Promise<void> {
+  const parsed = parseRoutineArgs(args);
+  const name = parsed.rest.join(' ').trim();
+  if (!name) {
+    ctx.print('Usage: /routines import-discovered <name> [--enabled] --yes');
+    return;
+  }
+  const discovered = findDiscoveredRoutine(await discoverRoutines(requireShellPaths(ctx)), name);
+  if (!discovered) {
+    ctx.print(`Unknown discovered Agent routine: ${name}\nRun /routines discover to inspect available routine files.`);
+    return;
+  }
+  if (!parsed.yes) {
+    ctx.print([
+      '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'));
+    return;
+  }
+  const routine = routineRegistry.create({
+    name: discovered.name,
+    description: discovered.description || `Imported routine from ${discovered.origin} markdown file.`,
+    steps: discovered.steps,
+    tags: frontmatterList(discovered, 'tags'),
+    triggers: frontmatterList(discovered, 'triggers'),
+    enabled: parsed.flags.get('enabled') === 'true',
+    source: 'imported',
+    provenance: `discovered:${discovered.origin}:${discovered.path}`,
+  });
+  ctx.print(`Imported Agent routine ${routine.id}: ${routine.name}${routine.enabled ? ' (enabled)' : ''}`);
+}
+
 async function promoteRoutine(args: readonly string[], routineRegistry: AgentRoutineRegistry, ctx: CommandContext): Promise<void> {
   const parsed = parseRoutineSchedulePromotionArgs(args);
   if (parsed.errors.length > 0) {
@@ -154,6 +231,14 @@ export async function runRoutinesRuntimeCommand(args: readonly string[], ctx: Co
       ctx.print(renderList('Enabled Agent Routines', routineRegistry, snapshot.enabledRoutines));
       return;
     }
+    if (sub === 'discover' || sub === 'discovered') {
+      ctx.print(renderDiscoveredRoutines(await discoverRoutines(requireShellPaths(ctx))));
+      return;
+    }
+    if (sub === 'import-discovered' || sub === 'import-routine') {
+      await importDiscoveredRoutine(args.slice(1), ctx, routineRegistry);
+      return;
+    }
     if (sub === 'search') {
       const query = args.slice(1).join(' ').trim();
       ctx.print(renderList(query ? `Agent Routines matching "${query}"` : 'Agent Routines', routineRegistry, routineRegistry.search(query)));
@@ -288,7 +373,7 @@ export async function runRoutinesRuntimeCommand(args: readonly string[], ctx: Co
       ctx.print(`Deleted Agent routine ${removed.id}: ${removed.name}`);
       return;
     }
-    ctx.print('Usage: /routines [list|enabled|search|show|receipts|reconcile|receipt|create|update|enable|disable|start|review|stale|promote|delete]');
+    ctx.print('Usage: /routines [list|enabled|discover|import-discovered|search|show|receipts|reconcile|receipt|create|update|enable|disable|start|review|stale|promote|delete]');
   } catch (error) {
     printError(ctx, error);
   }
@@ -299,7 +384,7 @@ export function registerRoutinesRuntimeCommands(registry: CommandRegistry): void
     name: 'routines',
     aliases: ['routine'],
     description: 'Manage local GoodVibes Agent routines',
-    usage: '[list|enabled|search <query>|show <id>|receipts|reconcile|receipt <id>|create --name <name> --description <summary> --steps <steps>|update <id> [--name ...] [--description ...] [--steps ...]|enable <id>|disable <id>|start <id>|review <id>|stale <id> <reason...>|promote <id> --cron <expr> [--delivery-channel slack] --yes|delete <id> --yes]',
+    usage: '[list|enabled|discover|import-discovered <name> --yes|search <query>|show <id>|receipts|reconcile|receipt <id>|create --name <name> --description <summary> --steps <steps>|update <id> [--name ...] [--description ...] [--steps ...]|enable <id>|disable <id>|start <id>|review <id>|stale <id> <reason...>|promote <id> --cron <expr> [--delivery-channel slack] --yes|delete <id> --yes]',
     handler: runRoutinesRuntimeCommand,
   });
 }

package/src/input/onboarding/onboarding-wizard-operator-steps.ts

@@ -1,4 +1,31 @@
 import type { OnboardingWizardStepDefinition } from './onboarding-wizard-types.ts';
+import type { AgentBehaviorDiscoverySnapshot } from '../../agent/behavior-discovery-summary.ts';
+
+function discoveryCount(discovery: AgentBehaviorDiscoverySnapshot | undefined): number {
+  if (!discovery) return 0;
+  return discovery.personas.count + discovery.skills.count + discovery.routines.count;
+}
+
+function discoverySummary(discovery: AgentBehaviorDiscoverySnapshot | undefined): string {
+  if (!discovery || discoveryCount(discovery) === 0) return 'No importable local behavior files found yet';
+  return [
+    `${discovery.personas.count} persona file(s)`,
+    `${discovery.skills.count} skill file(s)`,
+    `${discovery.routines.count} routine file(s)`,
+  ].join('; ');
+}
+
+function discoverySample(discovery: AgentBehaviorDiscoverySnapshot | undefined): string {
+  if (!discovery) return '';
+  const names = [
+    ...discovery.personas.names,
+    ...discovery.skills.names,
+    ...discovery.routines.names,
+  ].slice(0, 4);
+  if (names.length === 0) return 'Use /personas discover, /agent-skills discover, and /routines discover after setup to rescan.';
+  const remaining = discoveryCount(discovery) > names.length ? `, +${discoveryCount(discovery) - names.length} more` : '';
+  return `Import candidates: ${names.join(', ')}${remaining}.`;
+}
 
 export function buildCommunicationStep(): OnboardingWizardStepDefinition {
   return {
@@ -128,15 +155,19 @@ export function buildAgentKnowledgeStep(): OnboardingWizardStepDefinition {
   };
 }
 
-export function buildLocalStateStep(): OnboardingWizardStepDefinition {
+export function buildLocalStateStep(discovery?: AgentBehaviorDiscoverySnapshot): OnboardingWizardStepDefinition {
+  const discoveredCount = discoveryCount(discovery);
   return {
     id: 'agent-local-state',
     title: 'Local memory and behavior',
-    shortLabel: 'Memory',
-    description: 'Review the Agent-local behavior model. Memory, personas, skills, routines, and Agent profiles stay local until a stable shared registry exists.',
+    shortLabel: 'Behavior',
+    description: discoveredCount > 0
+      ? 'Review importable Agent-local behavior files, then create an isolated profile from them or import individual records.'
+      : 'Review the Agent-local behavior model. Memory, personas, skills, routines, and Agent profiles stay local until a stable shared registry exists.',
     summaryTitle: 'Local Agent state',
     summaryLines: [
       'Memory/personas/skills/routines: local Agent registries',
+      `Discovered behavior files: ${discoverySummary(discovery)}`,
       'Secrets: rejected or stored by secret reference',
       'Profiles: isolated Agent homes',
     ],
@@ -152,22 +183,28 @@ export function buildLocalStateStep(): OnboardingWizardStepDefinition {
         kind: 'status',
         id: 'agent-local-state.personas',
         label: 'Personas',
-        hint: 'Use /personas to create and activate serial operating modes for the main conversation.',
-        defaultValue: 'Local registry',
+        hint: discovery?.personas.count && discovery.personas.count > 0
+          ? `${discovery.personas.count} persona file(s) are available. Use the Profiles workspace to create a profile from discovered behavior, or preview individual files with /personas discover.`
+          : 'Use /personas to create and activate serial operating modes for the main conversation.',
+        defaultValue: discovery?.personas.count && discovery.personas.count > 0 ? `${discovery.personas.count} discovered` : 'Local registry',
       },
       {
         kind: 'status',
         id: 'agent-local-state.skills',
         label: 'Skills',
-        hint: 'Use /agent-skills and /skills local to manage reusable Agent procedures.',
-        defaultValue: 'Local registry',
+        hint: discovery?.skills.count && discovery.skills.count > 0
+          ? `${discovery.skills.count} skill file(s) are available. Use the Profiles workspace to create a profile from discovered behavior, or preview individual files with /agent-skills discover.`
+          : 'Use /agent-skills and /skills local to manage reusable Agent procedures.',
+        defaultValue: discovery?.skills.count && discovery.skills.count > 0 ? `${discovery.skills.count} discovered` : 'Local registry',
       },
       {
         kind: 'status',
         id: 'agent-local-state.routines',
         label: 'Routines',
-        hint: 'Use /routines for reusable local procedures. Starting a routine prints steps in the main conversation and does not spawn hidden work.',
-        defaultValue: 'Local registry',
+        hint: discovery?.routines.count && discovery.routines.count > 0
+          ? `${discovery.routines.count} routine file(s) are available. Use the Profiles workspace to create a profile from discovered behavior, or preview individual files with /routines discover. ${discoverySample(discovery)}`
+          : 'Use /routines for reusable local procedures. Starting a routine prints steps in the main conversation and does not spawn hidden work.',
+        defaultValue: discovery?.routines.count && discovery.routines.count > 0 ? `${discovery.routines.count} discovered` : 'Local registry',
       },
     ],
   };

package/src/input/onboarding/onboarding-wizard-steps.ts

@@ -31,7 +31,7 @@ export function buildOnboardingWizardSteps(controller: OnboardingWizardControlle
     buildCommunicationStep(),
     buildToolsStep(),
     buildAgentKnowledgeStep(),
-    buildLocalStateStep(),
+    buildLocalStateStep(controller.runtimeSnapshot?.localBehaviorDiscovery),
     buildAutomationStep(),
     buildVoiceMediaStep(),
     buildDelegationPolicyStep(),

package/src/renderer/agent-workspace.ts

@@ -104,6 +104,31 @@ function setupChecklistLines(snapshot: AgentWorkspaceRuntimeSnapshot): ContextLi
   return lines;
 }
 
+function discoverySummaryLine(label: string, summary: AgentWorkspaceRuntimeSnapshot['discoveredBehavior']['personas'], command: string): ContextLine[] {
+  if (summary.count === 0) return [];
+  const names = summary.names.length > 0
+    ? ` ${summary.names.join(', ')}${summary.count > summary.names.length ? `, +${summary.count - summary.names.length} more` : ''}.`
+    : '';
+  return [
+    { text: `${label}: ${summary.count} discovered; project ${summary.projectLocalCount}; global ${summary.globalCount}.`, fg: PALETTE.info, bold: true },
+    { text: `  ${command} to preview, then use the import form after review.${names}`, fg: PALETTE.muted },
+  ];
+}
+
+function behaviorDiscoveryLines(snapshot: AgentWorkspaceRuntimeSnapshot): ContextLine[] {
+  const lines: ContextLine[] = [
+    ...discoverySummaryLine('Discovered personas', snapshot.discoveredBehavior.personas, '/personas discover'),
+    ...discoverySummaryLine('Discovered skills', snapshot.discoveredBehavior.skills, '/agent-skills discover'),
+    ...discoverySummaryLine('Discovered routines', snapshot.discoveredBehavior.routines, '/routines discover'),
+  ];
+  if (lines.length === 0) return [];
+  return [
+    { text: '' },
+    { text: 'Discovered Behavior Files', fg: PALETTE.title, bold: true },
+    ...lines,
+  ];
+}
+
 function localLibraryLines(
   title: string,
   items: readonly AgentWorkspaceRuntimeSnapshot['localPersonas'][number][],
@@ -199,6 +224,7 @@ function snapshotLines(workspace: AgentWorkspace, category: AgentWorkspaceCatego
       { text: `Connection: ${snapshot.runtimeBaseUrl}`, fg: PALETTE.info },
       { text: 'Agent role: interactive operator TUI; setup changes here are Agent-local.', fg: PALETTE.good },
       ...setupChecklistLines(snapshot),
+      ...behaviorDiscoveryLines(snapshot),
       { text: '' },
       { text: `Workspace: ${snapshot.workingDirectory}`, fg: PALETTE.muted },
       { text: `Home: ${snapshot.homeDirectory}`, fg: PALETTE.muted },

package/src/runtime/onboarding/derivation.ts

@@ -211,7 +211,8 @@ function hasExternalIntegrations(snapshot: OnboardingSnapshotState): boolean {
 function hasLocalBehaviorCustomization(snapshot: OnboardingSnapshotState): boolean {
   return hasCustomizedWorkspaceDefaults(snapshot)
     || countPermissionToolOverrides(snapshot) > 0
-    || snapshot.runtimeDefaults.secretStoragePolicy !== DEFAULT_CONFIG.storage.secretPolicy;
+    || snapshot.runtimeDefaults.secretStoragePolicy !== DEFAULT_CONFIG.storage.secretPolicy
+    || countDiscoveredLocalBehavior(snapshot) > 0;
 }
 
 function hasCommunicationChannelSignals(snapshot: OnboardingSnapshotState): boolean {
@@ -240,6 +241,18 @@ function describeAgentKnowledge(): string {
 }
 
 function describeLocalBehavior(snapshot: OnboardingSnapshotState): string {
+  const discoveredCount = countDiscoveredLocalBehavior(snapshot);
+  if (discoveredCount > 0) {
+    const discovery = snapshot.localBehaviorDiscovery;
+    const samples = [
+      ...discovery.personas.names,
+      ...discovery.skills.names,
+      ...discovery.routines.names,
+    ].slice(0, 4);
+    const sampleText = samples.length > 0 ? ` Found: ${samples.join(', ')}.` : '';
+    return `Import ${discoveredCount} discovered Agent persona/skill/routine file(s) from local Agent folders before creating blank behavior.${sampleText}`;
+  }
+
   if (!hasLocalBehaviorCustomization(snapshot)) {
     return 'Configure local memory, routines, skills, personas, permissions, and secret handling before the Agent starts doing useful work.';
   }
@@ -247,6 +260,12 @@ function describeLocalBehavior(snapshot: OnboardingSnapshotState): string {
   return 'Review existing local behavior, permission, display, or secret-handling choices before applying Agent setup.';
 }
 
+function countDiscoveredLocalBehavior(snapshot: OnboardingSnapshotState): number {
+  return snapshot.localBehaviorDiscovery.personas.count
+    + snapshot.localBehaviorDiscovery.skills.count
+    + snapshot.localBehaviorDiscovery.routines.count;
+}
+
 function describeCommunicationChannels(snapshot: OnboardingSnapshotState): string {
   const integrationCount = new Set<string>([
     ...getExternalIntegrationServiceIds(snapshot),

package/src/runtime/onboarding/snapshot.ts

@@ -1,6 +1,7 @@
 import type { SecretStorageReview } from '../../config/secrets.ts';
 import { getProviderIdFromModel } from '../../config/provider-model.ts';
 import type { LocalAuthSnapshot } from '@pellux/goodvibes-sdk/platform/security';
+import { summarizeAgentBehaviorDiscovery } from '../../agent/behavior-discovery-summary.ts';
 import { readOnboardingRuntimeState } from './state.ts';
 import type {
   OnboardingAcknowledgementSnapshot,
@@ -400,6 +401,7 @@ export async function collectOnboardingSnapshot(
       records: sortSurfaceRecords(surfaceResult.value),
     },
     providerAccounts: providerAccountsResult.value,
+    localBehaviorDiscovery: summarizeAgentBehaviorDiscovery(deps.shellPaths),
     collectionIssues,
   };
 }

package/src/runtime/onboarding/types.ts

@@ -8,6 +8,7 @@ import type {
   ServiceInspectionQuery,
   SubscriptionAccessQuery,
 } from '../ui-service-queries.ts';
+import type { AgentBehaviorDiscoverySnapshot } from '../../agent/behavior-discovery-summary.ts';
 
 export type OnboardingMode = 'new' | 'edit' | 'reopen';
 
@@ -189,6 +190,7 @@ export interface OnboardingSnapshotState {
   readonly bindSettings: OnboardingBindSettingsSnapshot;
   readonly surfaces: OnboardingSurfacesSnapshot;
   readonly providerAccounts: OnboardingProviderAccountsSnapshot | null;
+  readonly localBehaviorDiscovery: AgentBehaviorDiscoverySnapshot;
   readonly collectionIssues: readonly OnboardingSnapshotCollectionIssue[];
 }