@pellux/goodvibes-agent 0.1.106 → 0.1.108

package/src/input/agent-workspace-reminder-schedule-editor.ts

@@ -0,0 +1,125 @@
+import type { AgentWorkspaceActionResult, AgentWorkspaceLocalEditor } from './agent-workspace-types.ts';
+import { isAffirmative } from './agent-workspace-editors.ts';
+import { quoteSlashCommandArg } from './slash-command-parser.ts';
+
+type AgentWorkspaceFieldReader = (fieldId: string) => string;
+type ReminderScheduleKind = 'cron' | 'every' | 'at';
+
+export type AgentReminderScheduleEditorSubmission =
+  | {
+    readonly kind: 'editor';
+    readonly editor: AgentWorkspaceLocalEditor;
+    readonly status: string;
+    readonly actionResult?: AgentWorkspaceActionResult;
+  }
+  | {
+    readonly kind: 'dispatch';
+    readonly command: string;
+    readonly status: string;
+    readonly actionResult: AgentWorkspaceActionResult;
+  };
+
+export function createReminderScheduleEditor(): AgentWorkspaceLocalEditor {
+  return {
+    kind: 'reminder-schedule',
+    mode: 'create',
+    title: 'Create Reminder',
+    selectedFieldIndex: 0,
+    message: 'Create one connected reminder schedule. Type yes on the final field to confirm.',
+    fields: [
+      { id: 'message', label: 'Reminder', value: '', required: true, multiline: true, hint: 'What should the Agent remind you about? Ctrl-J inserts a new line.' },
+      { id: 'scheduleKind', label: 'Schedule type', value: 'at', required: true, multiline: false, hint: 'at, every, or cron.' },
+      { id: 'scheduleValue', label: 'Schedule value', value: '', required: true, multiline: false, hint: 'Examples: 2026-06-01T09:00:00-05:00, 7d, or 0 9 * * *.' },
+      { id: 'timezone', label: 'Timezone', value: '', required: false, multiline: false, hint: 'Optional IANA timezone for cron schedules, for example America/Chicago.' },
+      { id: 'scheduleName', label: 'Schedule name', value: '', required: false, multiline: false, hint: 'Optional display name for the connected reminder.' },
+      { id: 'deliveryChannel', label: 'Delivery channel', value: '', required: false, multiline: false, hint: 'Optional channel target, for example slack or slack:ops-alerts:Ops.' },
+      { id: 'disabled', label: 'Create disabled', value: 'no', required: false, multiline: false, hint: 'yes/no. Default no.' },
+      { id: 'confirm', label: 'Confirm', value: '', required: true, multiline: false, hint: 'Type yes to run /schedule remind with --yes.' },
+    ],
+  };
+}
+
+export function buildAgentReminderScheduleEditorSubmission(
+  editor: AgentWorkspaceLocalEditor,
+  readField: AgentWorkspaceFieldReader,
+  commandDispatchAvailable: boolean,
+): AgentReminderScheduleEditorSubmission {
+  const confirm = readField('confirm');
+  if (!isAffirmative(confirm)) {
+    return {
+      kind: 'editor',
+      editor: { ...editor, message: 'Type yes to confirm reminder schedule creation.' },
+      status: 'Reminder schedule creation not confirmed.',
+    };
+  }
+
+  const scheduleKind = readScheduleKind(readField('scheduleKind'));
+  if (!scheduleKind) {
+    const detail = 'Schedule type must be at, every, or cron.';
+    return {
+      kind: 'editor',
+      editor: { ...editor, message: detail },
+      status: detail,
+      actionResult: {
+        kind: 'error',
+        title: 'Reminder schedule type invalid',
+        detail,
+      },
+    };
+  }
+
+  if (!commandDispatchAvailable) {
+    return {
+      kind: 'editor',
+      editor: { ...editor, message: 'Command dispatch is unavailable; cannot create a reminder from this workspace.' },
+      status: 'Command dispatch unavailable.',
+      actionResult: {
+        kind: 'error',
+        title: 'Command dispatch unavailable',
+        detail: 'The reminder schedule command cannot be opened from this runtime.',
+      },
+    };
+  }
+
+  const parts = [
+    '/schedule',
+    'remind',
+    '--message',
+    quoteSlashCommandArg(readField('message')),
+    `--${scheduleKind}`,
+    quoteSlashCommandArg(readField('scheduleValue')),
+  ];
+  const timezone = readField('timezone');
+  if (timezone.length > 0) parts.push('--timezone', quoteSlashCommandArg(timezone));
+  const scheduleName = readField('scheduleName');
+  if (scheduleName.length > 0) parts.push('--name', quoteSlashCommandArg(scheduleName));
+  const deliveryChannel = readField('deliveryChannel');
+  if (deliveryChannel.length > 0) parts.push('--delivery-channel', quoteSlashCommandArg(deliveryChannel));
+  if (isOptionalAffirmative(readField('disabled'))) parts.push('--disabled');
+  parts.push('--yes');
+  const command = parts.join(' ');
+
+  return {
+    kind: 'dispatch',
+    command,
+    status: 'Opening reminder schedule creation.',
+    actionResult: {
+      kind: 'dispatched',
+      title: 'Opening reminder schedule creation',
+      detail: 'The workspace handed a confirmed reminder schedule command to the shell-owned command router.',
+      command,
+      safety: 'safe',
+    },
+  };
+}
+
+function readScheduleKind(value: string): ReminderScheduleKind | null {
+  const normalized = value.trim().toLowerCase();
+  if (normalized === 'cron' || normalized === 'every' || normalized === 'at') return normalized;
+  return null;
+}
+
+function isOptionalAffirmative(value: string): boolean {
+  const normalized = value.trim().toLowerCase();
+  return normalized === 'yes' || normalized === 'y' || normalized === 'true' || normalized === 'enabled' || normalized === 'on';
+}

package/src/input/agent-workspace-routine-schedule-editor.ts

@@ -0,0 +1,127 @@
+import type { AgentWorkspaceActionResult, AgentWorkspaceLocalEditor, AgentWorkspaceLocalLibraryItem } from './agent-workspace-types.ts';
+import { isAffirmative } from './agent-workspace-editors.ts';
+import { quoteSlashCommandArg } from './slash-command-parser.ts';
+
+type AgentWorkspaceFieldReader = (fieldId: string) => string;
+type RoutineScheduleKind = 'cron' | 'every' | 'at';
+
+export type AgentRoutineScheduleEditorSubmission =
+  | {
+    readonly kind: 'editor';
+    readonly editor: AgentWorkspaceLocalEditor;
+    readonly status: string;
+    readonly actionResult?: AgentWorkspaceActionResult;
+  }
+  | {
+    readonly kind: 'dispatch';
+    readonly command: string;
+    readonly status: string;
+    readonly actionResult: AgentWorkspaceActionResult;
+  };
+
+export function createRoutineScheduleEditor(
+  selectedRoutine: AgentWorkspaceLocalLibraryItem | null,
+): AgentWorkspaceLocalEditor {
+  const selected = selectedRoutine ? `${selectedRoutine.id} (${selectedRoutine.name})` : 'No routine selected';
+  return {
+    kind: 'routine-schedule',
+    mode: 'create',
+    title: 'Promote Routine to Schedule',
+    selectedFieldIndex: 0,
+    message: `Create one connected schedule from a reviewed local routine. Selected: ${selected}. Type yes on the final field to confirm.`,
+    fields: [
+      { id: 'routineId', label: 'Routine id', value: selectedRoutine?.id ?? '', required: true, multiline: false, hint: 'Local Agent routine id to promote.' },
+      { id: 'scheduleKind', label: 'Schedule type', value: 'cron', required: true, multiline: false, hint: 'cron, every, or at.' },
+      { id: 'scheduleValue', label: 'Schedule value', value: '', required: true, multiline: false, hint: 'Examples: 0 9 * * *, 7d, or 2026-06-01T09:00:00-05:00.' },
+      { id: 'timezone', label: 'Timezone', value: '', required: false, multiline: false, hint: 'Optional IANA timezone, for example America/Chicago.' },
+      { id: 'scheduleName', label: 'Schedule name', value: selectedRoutine?.name ?? '', required: false, multiline: false, hint: 'Optional display name for the connected schedule.' },
+      { id: 'deliveryChannel', label: 'Delivery channel', value: '', required: false, multiline: false, hint: 'Optional channel target, for example slack or slack:ops-alerts:Ops.' },
+      { id: 'disabled', label: 'Create disabled', value: 'no', required: false, multiline: false, hint: 'yes/no. Default no.' },
+      { id: 'confirm', label: 'Confirm', value: '', required: true, multiline: false, hint: 'Type yes to run /schedule promote-routine with --yes.' },
+    ],
+  };
+}
+
+export function buildAgentRoutineScheduleEditorSubmission(
+  editor: AgentWorkspaceLocalEditor,
+  readField: AgentWorkspaceFieldReader,
+  commandDispatchAvailable: boolean,
+): AgentRoutineScheduleEditorSubmission {
+  const confirm = readField('confirm');
+  if (!isAffirmative(confirm)) {
+    return {
+      kind: 'editor',
+      editor: { ...editor, message: 'Type yes to confirm routine schedule promotion.' },
+      status: 'Routine schedule promotion not confirmed.',
+    };
+  }
+
+  const scheduleKind = readScheduleKind(readField('scheduleKind'));
+  if (!scheduleKind) {
+    const detail = 'Schedule type must be cron, every, or at.';
+    return {
+      kind: 'editor',
+      editor: { ...editor, message: detail },
+      status: detail,
+      actionResult: {
+        kind: 'error',
+        title: 'Routine schedule type invalid',
+        detail,
+      },
+    };
+  }
+
+  if (!commandDispatchAvailable) {
+    return {
+      kind: 'editor',
+      editor: { ...editor, message: 'Command dispatch is unavailable; cannot promote a routine from this workspace.' },
+      status: 'Command dispatch unavailable.',
+      actionResult: {
+        kind: 'error',
+        title: 'Command dispatch unavailable',
+        detail: 'The routine schedule promotion command cannot be opened from this runtime.',
+      },
+    };
+  }
+
+  const parts = [
+    '/schedule',
+    'promote-routine',
+    quoteSlashCommandArg(readField('routineId')),
+    `--${scheduleKind}`,
+    quoteSlashCommandArg(readField('scheduleValue')),
+  ];
+  const timezone = readField('timezone');
+  if (timezone.length > 0) parts.push('--timezone', quoteSlashCommandArg(timezone));
+  const scheduleName = readField('scheduleName');
+  if (scheduleName.length > 0) parts.push('--name', quoteSlashCommandArg(scheduleName));
+  const deliveryChannel = readField('deliveryChannel');
+  if (deliveryChannel.length > 0) parts.push('--delivery-channel', quoteSlashCommandArg(deliveryChannel));
+  if (isOptionalAffirmative(readField('disabled'))) parts.push('--disabled');
+  parts.push('--yes');
+  const command = parts.join(' ');
+
+  return {
+    kind: 'dispatch',
+    command,
+    status: 'Opening routine schedule promotion.',
+    actionResult: {
+      kind: 'dispatched',
+      title: 'Opening routine schedule promotion',
+      detail: 'The workspace handed a confirmed routine schedule promotion command to the shell-owned command router.',
+      command,
+      safety: 'safe',
+    },
+  };
+}
+
+function readScheduleKind(value: string): RoutineScheduleKind | null {
+  const normalized = value.trim().toLowerCase();
+  if (normalized === 'cron' || normalized === 'every' || normalized === 'at') return normalized;
+  return null;
+}
+
+function isOptionalAffirmative(value: string): boolean {
+  const normalized = value.trim().toLowerCase();
+  return normalized === 'yes' || normalized === 'y' || normalized === 'true' || normalized === 'enabled' || normalized === 'on';
+}

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

@@ -39,9 +39,9 @@ export function buildAgentWorkspaceSetupChecklist(input: AgentWorkspaceSetupChec
   return [
     {
       id: 'runtime',
-      label: 'GoodVibes runtime',
+      label: 'Connected services',
       status: 'ready',
-      detail: `Agent will connect to ${input.runtimeBaseUrl}; runtime ownership stays outside this product.`,
+      detail: `Agent will connect to ${input.runtimeBaseUrl}; service ownership stays outside this product.`,
       command: '/health',
     },
     {

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

@@ -10,6 +10,24 @@ export type AgentWorkspaceActionKind = 'command' | 'guidance' | 'workspace' | 'e
 
 export type AgentWorkspaceLocalEditorKind = 'memory' | 'persona' | 'skill' | 'routine' | 'profile';
 
+export type AgentWorkspaceEditorKind =
+  | AgentWorkspaceLocalEditorKind
+  | 'knowledge-url'
+  | 'knowledge-file'
+  | 'knowledge-bookmarks'
+  | 'knowledge-browser-history'
+  | 'knowledge-connector-ingest'
+  | 'knowledge-search'
+  | 'knowledge-ask'
+  | 'tts-prompt'
+  | 'image-input'
+  | 'skill-bundle'
+  | 'skill-discovery-import'
+  | 'profile-template-export'
+  | 'profile-template-import'
+  | 'routine-schedule'
+  | 'reminder-schedule';
+
 export type AgentWorkspaceLocalOperation =
   | 'memory-edit'
   | 'memory-review'
@@ -42,7 +60,7 @@ export interface AgentWorkspaceEditorField {
 }
 
 export interface AgentWorkspaceLocalEditor {
-  readonly kind: AgentWorkspaceLocalEditorKind;
+  readonly kind: AgentWorkspaceEditorKind;
   readonly mode: 'create' | 'update' | 'delete';
   readonly recordId?: string;
   readonly title: string;
@@ -57,7 +75,7 @@ export interface AgentWorkspaceAction {
   readonly detail: string;
   readonly command?: string;
   readonly targetCategoryId?: string;
-  readonly editorKind?: AgentWorkspaceLocalEditorKind;
+  readonly editorKind?: AgentWorkspaceEditorKind;
   readonly localKind?: AgentWorkspaceLocalEditorKind;
   readonly selectionDelta?: number;
   readonly localOperation?: AgentWorkspaceLocalOperation;

package/src/input/agent-workspace-voice-media.ts

@@ -123,8 +123,8 @@ function buildProviderStatus(
   const nextStep = setupState === 'ready'
     ? `${label} is ready for explicit Agent voice/media use.`
     : setupState === 'needs-secret'
-      ? `Configure one of ${spec.secretKeyOptions.join('|')} in the owning runtime environment.`
-      : `${label} is registered; confirm any provider-specific setup in the owning runtime.`;
+      ? `Configure one of ${spec.secretKeyOptions.join('|')} in the owning GoodVibes host environment.`
+      : `${label} is registered; confirm any provider-specific setup in the owning GoodVibes host.`;
   return {
     id: provider.id,
     label,
@@ -150,7 +150,7 @@ function missingSelectedProviderStatus(selectedProviderId: string): AgentWorkspa
     secretKeyOptions: [],
     configuredSecretKeys: [],
     missingSecretKeyOptions: [],
-    nextStep: `Selected TTS provider ${selectedProviderId} is not registered in this runtime.`,
+    nextStep: `Selected TTS provider ${selectedProviderId} is not registered in connected GoodVibes services.`,
   };
 }
 
@@ -168,9 +168,9 @@ function browserToolState(context: CommandContext): AgentWorkspaceVoiceMediaRead
 }
 
 function browserToolNextStep(state: AgentWorkspaceVoiceMediaReadiness['browserToolState']): string {
-  if (state === 'disabled') return 'Inspect MCP browser/automation tools; enable browser access in the owning runtime only when needed.';
+  if (state === 'disabled') return 'Inspect MCP browser/automation tools; enable browser access in the owning GoodVibes host only when needed.';
   if (state === 'local-only') return 'Browser tooling is local-only; keep external exposure off unless explicitly configured.';
-  return 'Public browser URL is configured; use explicit user action and runtime policy before browser-side effects.';
+  return 'Public browser URL is configured; use explicit user action and Agent policy before browser-side effects.';
 }
 
 export function buildAgentWorkspaceVoiceMediaReadiness(options: {

package/src/input/agent-workspace.ts

@@ -8,6 +8,8 @@ import { createAgentRuntimeProfile, type AgentRuntimeProfileInfo } from '../agen
 import { AgentSkillRegistry } from '../agent/skill-registry.ts';
 import { activateAgentWorkspaceSelection } from './agent-workspace-activation.ts';
 import { AGENT_WORKSPACE_CATEGORIES } from './agent-workspace-categories.ts';
+import { buildAgentWorkspaceCommandEditorSubmission, isAgentWorkspaceCommandEditorKind } from './agent-workspace-command-editor.ts';
+import { quoteSlashCommandArg } from './slash-command-parser.ts';
 import { createDeleteEditor, createMemoryUpdateEditor, createPersonaUpdateEditor, createRoutineUpdateEditor, createSkillUpdateEditor, editorCategoryId, isAffirmative, splitList } from './agent-workspace-editors.ts';
 import { deleteAgentWorkspaceMemoryEditor, submitAgentWorkspaceMemoryEditor } from './agent-workspace-memory-editor.ts';
 import { buildAgentWorkspaceRuntimeSnapshot } from './agent-workspace-snapshot.ts';
@@ -379,6 +381,19 @@ export class AgentWorkspace {
           safety: 'safe',
         };
       } else if (operation === 'routine-start') {
+        if (this.hasCommandDispatch()) {
+          const command = `/routines start ${quoteSlashCommandArg(selected.id)}`;
+          this.dispatchWorkspaceCommand(command);
+          this.status = `Opening routine: ${selected.name}.`;
+          this.lastActionResult = {
+            kind: 'dispatched',
+            title: `Opening routine ${selected.name}`,
+            detail: `${selected.name} will print its workflow steps in the main conversation. No hidden job was created.`,
+            command,
+            safety: 'safe',
+          };
+          return;
+        }
         AgentRoutineRegistry.fromShellPaths(shellPaths).markStarted(selected.id);
         this.finishLocalOperation('routine', `Started routine ${selected.name}`, `${selected.name} was marked started for this main-conversation workflow. No hidden job was created.`);
       } else if (operation === 'routine-enable') {
@@ -472,6 +487,11 @@ export class AgentWorkspace {
       this.status = `${missing.label} is required.`;
       return;
     }
+    if (isAgentWorkspaceCommandEditorKind(editor.kind)) {
+      this.submitCommandEditor(editor);
+      requestRender?.();
+      return;
+    }
     if (editor.kind === 'memory') {
       if (editor.mode === 'delete') {
         try {
@@ -608,6 +628,21 @@ export class AgentWorkspace {
     }
   }
 
+  private submitCommandEditor(editor: AgentWorkspaceLocalEditor): void {
+    const result = buildAgentWorkspaceCommandEditorSubmission(editor, (fieldId) => this.editorField(fieldId), this.hasCommandDispatch());
+    if (result.kind === 'editor') {
+      this.localEditor = result.editor;
+      this.status = result.status;
+      if (result.actionResult) this.lastActionResult = result.actionResult;
+      return;
+    }
+
+    this.localEditor = null;
+    this.status = result.status;
+    this.lastActionResult = result.actionResult;
+    this.dispatchWorkspaceCommand(result.command);
+  }
+
   private submitLocalDeleteEditor(shellPaths: ShellPathService, editor: AgentWorkspaceLocalEditor): void {
     const expectedId = editor.recordId ?? '';
     const confirmedId = this.editorField('confirm');
@@ -629,9 +664,11 @@ export class AgentWorkspace {
     } else if (editor.kind === 'skill') {
       const removed = AgentSkillRegistry.fromShellPaths(shellPaths).deleteSkill(expectedId);
       this.finishLocalDelete(editor.kind, removed.id, removed.name);
-    } else {
+    } else if (editor.kind === 'routine') {
       const removed = AgentRoutineRegistry.fromShellPaths(shellPaths).deleteRoutine(expectedId);
       this.finishLocalDelete(editor.kind, removed.id, removed.name);
+    } else {
+      throw new Error(`Unsupported delete editor kind: ${editor.kind}`);
     }
   }
 
@@ -647,7 +684,7 @@ export class AgentWorkspace {
       this.status = 'Deletion not confirmed.';
       return;
     }
-    this.finishLocalDelete(editor.kind, removed.id, removed.name);
+    this.finishLocalDelete('memory', removed.id, removed.name);
   }
 
   private async submitMemoryEditor(editor: AgentWorkspaceLocalEditor): Promise<void> {

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

@@ -83,7 +83,7 @@ function renderGuide(homeDirectory: string): string {
     '5. Create an Agent profile from the imported starter:',
     '   /agent-profile create <name> --template <imported-id> --yes',
     '',
-    'This writes only Agent-local starter/profile state. It does not mutate the runtime host, default wiki, or non-Agent knowledge segments.',
+    'This writes only Agent-local starter/profile state. It does not mutate connected GoodVibes services, default wiki, or non-Agent knowledge segments.',
   ].join('\n');
 }
 

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

@@ -1,4 +1,5 @@
 import { AgentSkillRegistry, type AgentSkillBundleRecord, type AgentSkillRecord } from '../../agent/skill-registry.ts';
+import { discoverSkills, type SkillRecord } from '../../agent/skill-discovery.ts';
 import type { CommandContext, CommandRegistry } from '../command-registry.ts';
 import { requireShellPaths } from './runtime-services.ts';
 
@@ -73,6 +74,89 @@ function renderList(title: string, registry: AgentSkillRegistry, skills: readonl
   ].join('\n');
 }
 
+function summarizeDiscoveredSkill(skill: SkillRecord): string {
+  const description = skill.description ? ` - ${skill.description}` : '';
+  const dependencies = skill.dependencies.length > 0 ? ` deps=${skill.dependencies.join(',')}` : '';
+  const includes = skill.includes.length > 0 ? ` includes=${skill.includes.join(',')}` : '';
+  return `  ${skill.name}  ${skill.origin}${description}${dependencies}${includes}\n    path: ${skill.path}`;
+}
+
+function renderDiscoveredSkills(skills: readonly SkillRecord[]): string {
+  if (skills.length === 0) {
+    return [
+      'Discovered Agent skill files',
+      '  No SKILL.md or .md skill files found in project/global Agent skill folders.',
+      '  Search roots: .goodvibes/skills, .goodvibes/agent/skills, ~/.goodvibes/skills, ~/.goodvibes/agent/skills',
+    ].join('\n');
+  }
+  return [
+    `Discovered Agent skill files (${skills.length})`,
+    ...skills.map(summarizeDiscoveredSkill),
+    '',
+    'Import one with: /agent-skills import-discovered <name> --yes',
+  ].join('\n');
+}
+
+function discoveredSkillLookupValues(skill: SkillRecord): readonly string[] {
+  const slug = skill.name.trim().toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/^-+|-+$/g, '');
+  const basename = skill.path.split(/[\\/]/).pop()?.replace(/\.md$/i, '') ?? '';
+  return [
+    skill.name,
+    slug,
+    skill.path,
+    basename,
+  ].map((value) => value.trim().toLowerCase()).filter(Boolean);
+}
+
+function findDiscoveredSkill(skills: readonly SkillRecord[], idOrName: string): SkillRecord | null {
+  const lookup = idOrName.trim().toLowerCase();
+  if (!lookup) return null;
+  return skills.find((skill) => discoveredSkillLookupValues(skill).includes(lookup)) ?? null;
+}
+
+function frontmatterList(skill: SkillRecord, key: string): readonly string[] {
+  const value = skill.frontmatter[key];
+  if (!value) return [];
+  return splitList(value);
+}
+
+async function importDiscoveredSkill(args: readonly string[], ctx: CommandContext, skillRegistry: AgentSkillRegistry): Promise<void> {
+  const parsed = parseSkillArgs(args);
+  const name = parsed.rest.join(' ').trim();
+  if (!name) {
+    ctx.print('Usage: /agent-skills import-discovered <name> [--enabled] --yes');
+    return;
+  }
+  const discovered = findDiscoveredSkill(await discoverSkills(requireShellPaths(ctx)), name);
+  if (!discovered) {
+    ctx.print(`Unknown discovered Agent skill: ${name}\nRun /agent-skills discover to inspect available skill files.`);
+    return;
+  }
+  if (!parsed.yes) {
+    ctx.print([
+      'Agent skill import preview',
+      `  name: ${discovered.name}`,
+      `  origin: ${discovered.origin}`,
+      `  path: ${discovered.path}`,
+      `  description: ${discovered.description || '(none)'}`,
+      `  procedure characters: ${discovered.body.length}`,
+      '  next: rerun with --yes to import into the Agent-local skill registry',
+    ].join('\n'));
+    return;
+  }
+  const skill = skillRegistry.create({
+    name: discovered.name,
+    description: discovered.description || `Imported skill from ${discovered.origin} skill file.`,
+    procedure: discovered.body,
+    triggers: frontmatterList(discovered, 'triggers'),
+    tags: frontmatterList(discovered, 'tags'),
+    enabled: parsed.flags.get('enabled') === 'true',
+    source: 'imported',
+    provenance: `discovered:${discovered.origin}:${discovered.path}`,
+  });
+  ctx.print(`Imported Agent skill ${skill.id}: ${skill.name}`);
+}
+
 function renderBundleList(title: string, registry: AgentSkillRegistry, bundles: readonly AgentSkillBundleRecord[]): string {
   const snapshot = registry.snapshot();
   if (bundles.length === 0) {
@@ -248,6 +332,14 @@ export async function runAgentSkillsRuntimeCommand(args: readonly string[], ctx:
       runBundleCommand(args.slice(1), ctx, skillRegistry);
       return;
     }
+    if (sub === 'discover' || sub === 'discovered') {
+      ctx.print(renderDiscoveredSkills(await discoverSkills(requireShellPaths(ctx))));
+      return;
+    }
+    if (sub === 'import-discovered' || sub === 'import-skill') {
+      await importDiscoveredSkill(args.slice(1), ctx, skillRegistry);
+      return;
+    }
     if (sub === 'list' || sub === 'open') {
       ctx.print(renderList('Agent Skills', skillRegistry, skillRegistry.list()));
       return;
@@ -351,7 +443,7 @@ export async function runAgentSkillsRuntimeCommand(args: readonly string[], ctx:
       ctx.print(`Deleted Agent skill ${removed.id}: ${removed.name}`);
       return;
     }
-    ctx.print('Usage: /agent-skills [list|enabled|search|show|create|update|enable|disable|review|stale|delete|bundle]');
+    ctx.print('Usage: /agent-skills [list|enabled|discover|import-discovered|search|show|create|update|enable|disable|review|stale|delete|bundle]');
   } catch (error) {
     printError(ctx, error);
   }
@@ -362,7 +454,7 @@ export function registerAgentSkillsRuntimeCommands(registry: CommandRegistry): v
     name: 'agent-skills',
     aliases: ['askills', 'local-skills', 'skills', 'skill'],
     description: 'Manage local GoodVibes Agent skills',
-    usage: '[list|enabled|search <query>|show <id>|create --name <name> --description <summary> --procedure <steps>|update <id> [--name ...] [--description ...] [--procedure ...]|enable <id>|disable <id>|review <id>|stale <id> <reason...>|delete <id> --yes|bundle ...]',
+    usage: '[list|enabled|discover|import-discovered <name> --yes|search <query>|show <id>|create --name <name> --description <summary> --procedure <steps>|update <id> [--name ...] [--description ...] [--procedure ...]|enable <id>|disable <id>|review <id>|stale <id> <reason...>|delete <id> --yes|bundle ...]',
     handler: runAgentSkillsRuntimeCommand,
   });
 }