@pellux/goodvibes-agent 0.1.113 → 0.1.114

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

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/version.ts

@@ -6,7 +6,7 @@ import { join } from 'node:path';
 // The prebuild script updates the fallback value before compilation.
 // Uses import.meta.dir (Bun) to locate package.json relative to this file,
 // which is correct regardless of the process working directory.
-let _version = '0.1.113';
+let _version = '0.1.114';
 let _sdkVersion = '0.33.35';
 try {
   const pkg = JSON.parse(readFileSync(join(import.meta.dir, '..', 'package.json'), 'utf-8')) as {