@pellux/goodvibes-agent 0.1.114 → 0.1.117

package/src/input/agent-workspace-workplan-editor-submission.ts

@@ -0,0 +1,153 @@
+import type { AgentWorkspaceActionResult, AgentWorkspaceLocalEditor } from './agent-workspace-types.ts';
+import { quoteSlashCommandArg } from './slash-command-parser.ts';
+
+type AgentWorkspaceFieldReader = (fieldId: string) => string;
+
+export type AgentWorkspaceWorkPlanEditorKind = 'workplan-add' | 'workplan-show' | 'workplan-status' | 'workplan-delete' | 'workplan-clear-completed';
+
+export type AgentWorkspaceWorkPlanEditorSubmission =
+  | {
+    readonly kind: 'editor';
+    readonly editor: AgentWorkspaceLocalEditor;
+    readonly status: string;
+    readonly actionResult?: AgentWorkspaceActionResult;
+  }
+  | {
+    readonly kind: 'dispatch';
+    readonly command: string;
+    readonly status: string;
+    readonly actionResult: AgentWorkspaceActionResult;
+  };
+
+const STATUS_COMMANDS: Record<string, string> = {
+  pending: 'pending',
+  todo: 'pending',
+  start: 'start',
+  active: 'start',
+  progress: 'start',
+  in_progress: 'start',
+  blocked: 'blocked',
+  block: 'blocked',
+  done: 'done',
+  complete: 'done',
+  completed: 'done',
+  failed: 'failed',
+  fail: 'failed',
+  cancelled: 'cancelled',
+  canceled: 'cancelled',
+  cancel: 'cancelled',
+};
+
+export function isAgentWorkspaceWorkPlanEditorKind(kind: string): kind is AgentWorkspaceWorkPlanEditorKind {
+  return kind === 'workplan-add'
+    || kind === 'workplan-show'
+    || kind === 'workplan-status'
+    || kind === 'workplan-delete'
+    || kind === 'workplan-clear-completed';
+}
+
+function isAffirmative(value: string): boolean {
+  return /^(y|yes|true)$/i.test(value.trim());
+}
+
+function unconfirmed(editor: AgentWorkspaceLocalEditor, message: string, status: string): AgentWorkspaceWorkPlanEditorSubmission {
+  return {
+    kind: 'editor',
+    editor: { ...editor, message },
+    status,
+  };
+}
+
+function dispatch(command: string, title: string, status: string, detail: string, safety: 'safe' | 'read-only' | 'delegates' | 'blocked'): AgentWorkspaceWorkPlanEditorSubmission {
+  return {
+    kind: 'dispatch',
+    command,
+    status,
+    actionResult: {
+      kind: 'dispatched',
+      title,
+      detail,
+      command,
+      safety,
+    },
+  };
+}
+
+export function buildAgentWorkspaceWorkPlanEditorSubmission(
+  editor: AgentWorkspaceLocalEditor,
+  readField: AgentWorkspaceFieldReader,
+): AgentWorkspaceWorkPlanEditorSubmission {
+  if (editor.kind === 'workplan-add') {
+    const parts = ['/workplan', 'add', quoteSlashCommandArg(readField('title'))];
+    const owner = readField('owner');
+    const source = readField('source');
+    const notes = readField('notes');
+    if (owner.length > 0) parts.push('--owner', quoteSlashCommandArg(owner));
+    if (source.length > 0) parts.push('--source', quoteSlashCommandArg(source));
+    if (notes.length > 0) parts.push('--notes', quoteSlashCommandArg(notes));
+    return dispatch(
+      parts.join(' '),
+      'Opening work plan item creation',
+      'Opening work plan item creation.',
+      'The workspace handed a visible work plan item creation command to the shell-owned command router.',
+      'safe',
+    );
+  }
+
+  if (editor.kind === 'workplan-show') {
+    const format = readField('format').trim().toLowerCase();
+    const command = format === 'markdown' ? '/workplan markdown' : '/workplan show';
+    return dispatch(
+      command,
+      'Opening work plan detail',
+      'Opening work plan detail.',
+      'The workspace handed read-only work plan detail inspection to the shell-owned command router.',
+      'read-only',
+    );
+  }
+
+  if (editor.kind === 'workplan-status') {
+    const requested = readField('status').trim().toLowerCase().replace(/[\s-]+/g, '_');
+    const commandStatus = STATUS_COMMANDS[requested];
+    if (!commandStatus) {
+      return {
+        kind: 'editor',
+        editor: { ...editor, message: 'Invalid status. Use pending, start, blocked, done, failed, or cancelled.' },
+        status: 'Work plan status update needs a valid status.',
+      };
+    }
+    const command = `/workplan ${commandStatus} ${quoteSlashCommandArg(readField('id'))}`;
+    return dispatch(
+      command,
+      'Opening work plan status update',
+      'Opening work plan status update.',
+      'The workspace handed a visible work plan status update command to the shell-owned command router.',
+      'safe',
+    );
+  }
+
+  if (editor.kind === 'workplan-delete') {
+    if (!isAffirmative(readField('confirm'))) {
+      return unconfirmed(editor, 'Work plan removal not confirmed. Type yes, then press Enter.', 'Work plan removal not confirmed.');
+    }
+    const command = `/workplan remove ${quoteSlashCommandArg(readField('id'))} --yes`;
+    return dispatch(
+      command,
+      'Opening work plan item removal',
+      'Opening work plan item removal.',
+      'The workspace handed a confirmed work plan removal command to the shell-owned command router.',
+      'safe',
+    );
+  }
+
+  if (!isAffirmative(readField('confirm'))) {
+    return unconfirmed(editor, 'Clear completed work plan items not confirmed. Type yes, then press Enter.', 'Clear completed work plan items not confirmed.');
+  }
+  return dispatch(
+    '/workplan clear-completed --yes',
+    'Opening completed work plan cleanup',
+    'Opening completed work plan cleanup.',
+    'The workspace handed a confirmed work plan cleanup command to the shell-owned command router.',
+    'safe',
+  );
+}

package/src/input/agent-workspace.ts

@@ -11,24 +11,15 @@ 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 { createAgentWorkspaceLearnedBehavior } from './agent-workspace-learned-behavior.ts';
 import { deleteAgentWorkspaceMemoryEditor, submitAgentWorkspaceMemoryEditor } from './agent-workspace-memory-editor.ts';
+import { jumpAgentWorkspaceSelection, moveAgentWorkspaceSelection, selectAgentWorkspaceCategory } from './agent-workspace-navigation.ts';
+import { buildAgentWorkspaceRequirements } from './agent-workspace-requirements.ts';
 import { buildAgentWorkspaceRuntimeSnapshot } from './agent-workspace-snapshot.ts';
 import type { AgentWorkspaceAction, AgentWorkspaceActionResult, AgentWorkspaceCategory, AgentWorkspaceCommandDispatcher, AgentWorkspaceEditorField, AgentWorkspaceFocusPane, AgentWorkspaceLocalEditor, AgentWorkspaceLocalEditorKind, AgentWorkspaceLocalLibraryItem, AgentWorkspaceLocalOperation, AgentWorkspaceRuntimeSnapshot } from './agent-workspace-types.ts';
 
 export type { AgentWorkspaceChannelRisk, AgentWorkspaceChannelStatus } from './agent-workspace-channels.ts';
-export type {
-  AgentWorkspaceAction,
-  AgentWorkspaceActionResult,
-  AgentWorkspaceCategory,
-  AgentWorkspaceCommandDispatcher,
-  AgentWorkspaceEditorField,
-  AgentWorkspaceFocusPane,
-  AgentWorkspaceLocalEditor,
-  AgentWorkspaceLocalEditorKind,
-  AgentWorkspaceLocalLibraryItem,
-  AgentWorkspaceLocalOperation,
-  AgentWorkspaceRuntimeSnapshot,
-} from './agent-workspace-types.ts';
+export type { AgentWorkspaceAction, AgentWorkspaceActionResult, AgentWorkspaceCategory, AgentWorkspaceCommandDispatcher, AgentWorkspaceEditorField, AgentWorkspaceFocusPane, AgentWorkspaceLocalEditor, AgentWorkspaceLocalEditorKind, AgentWorkspaceLocalLibraryItem, AgentWorkspaceLocalOperation, AgentWorkspaceRuntimeSnapshot } from './agent-workspace-types.ts';
 export { AGENT_WORKSPACE_MODAL_NAME } from './agent-workspace-types.ts';
 export { buildAgentWorkspaceRuntimeSnapshot } from './agent-workspace-snapshot.ts';
 export { handleAgentWorkspaceToken } from './agent-workspace-token.ts';
@@ -52,7 +43,7 @@ export class AgentWorkspace {
   private context: CommandContext | null = null;
   private dispatchCommand: AgentWorkspaceCommandDispatcher | null = null;
 
-  open(context: CommandContext, dispatchCommand: AgentWorkspaceCommandDispatcher): void {
+  open(context: CommandContext, dispatchCommand: AgentWorkspaceCommandDispatcher, categoryId?: string): void {
     this.context = context;
     this.dispatchCommand = dispatchCommand;
     this.runtimeSnapshot = buildAgentWorkspaceRuntimeSnapshot(context);
@@ -61,6 +52,16 @@ export class AgentWorkspace {
     this.status = 'Ready. Choose an operator flow; ordinary assistant work stays in the main conversation.';
     this.lastActionResult = null;
     this.localEditor = null;
+    if (categoryId && !this.selectCategory(categoryId)) {
+      const normalized = categoryId.trim();
+      this.status = `Unknown Agent workspace area: ${normalized}.`;
+      this.lastActionResult = {
+        kind: 'guidance',
+        title: 'Unknown Agent workspace area',
+        detail: `Use one of: ${this.categories.map((category) => category.id).join(', ')}.`,
+        safety: 'safe',
+      };
+    }
     this.clampSelection();
   }
 
@@ -90,6 +91,10 @@ export class AgentWorkspace {
     return this.actions[this.selectedActionIndex] ?? null;
   }
 
+  selectCategory(categoryIdOrLabel: string): boolean {
+    return selectAgentWorkspaceCategory(this, categoryIdOrLabel);
+  }
+
   selectedLocalLibraryItem(kind: AgentWorkspaceLocalEditorKind): AgentWorkspaceLocalLibraryItem | null {
     const items = this.localLibraryItems(kind);
     if (items.length === 0) return null;
@@ -110,35 +115,19 @@ export class AgentWorkspace {
   }
 
   moveUp(): void {
-    if (this.focusPane === 'categories') {
-      this.selectedCategoryIndex = Math.max(0, this.selectedCategoryIndex - 1);
-      this.selectedActionIndex = 0;
-    } else {
-      this.selectedActionIndex = Math.max(0, this.selectedActionIndex - 1);
-    }
-    this.clampSelection();
+    moveAgentWorkspaceSelection(this, -1);
   }
 
   moveDown(): void {
-    if (this.focusPane === 'categories') {
-      this.selectedCategoryIndex = Math.min(this.categories.length - 1, this.selectedCategoryIndex + 1);
-      this.selectedActionIndex = 0;
-    } else {
-      this.selectedActionIndex = Math.min(this.actions.length - 1, this.selectedActionIndex + 1);
-    }
-    this.clampSelection();
+    moveAgentWorkspaceSelection(this, 1);
   }
 
   jumpHome(): void {
-    if (this.focusPane === 'categories') this.selectedCategoryIndex = 0;
-    else this.selectedActionIndex = 0;
-    this.clampSelection();
+    jumpAgentWorkspaceSelection(this, 'home');
   }
 
   jumpEnd(): void {
-    if (this.focusPane === 'categories') this.selectedCategoryIndex = this.categories.length - 1;
-    else this.selectedActionIndex = this.actions.length - 1;
-    this.clampSelection();
+    jumpAgentWorkspaceSelection(this, 'end');
   }
 
   refreshRuntimeSnapshot(): void {
@@ -184,7 +173,7 @@ export class AgentWorkspace {
     if (!editor || text.length === 0) return;
     const field = editor.fields[editor.selectedFieldIndex];
     if (!field) return;
-    this.replaceEditorField(editor.selectedFieldIndex, `${field.value}${text}`, editor.message);
+    this.replaceEditorField(editor.selectedFieldIndex, `${field.value}${field.multiline ? text.replace(/\r\n?/g, '\n') : text.replace(/[\r\n]+/g, ' ')}`, editor.message);
   }
 
   appendEditorNewline(): void {
@@ -432,6 +421,12 @@ export class AgentWorkspace {
     return memory;
   }
 
+  private learnedBehaviorTarget(): Exclude<AgentWorkspaceLocalEditorKind, 'memory' | 'profile'> {
+    const target = this.editorField('target').trim().toLowerCase();
+    if (target === 'persona' || target === 'skill' || target === 'routine') return target;
+    throw new Error('Behavior type must be skill, routine, or persona.');
+  }
+
   private finishLocalOperation(kind: AgentWorkspaceLocalEditorKind, title: string, detail: string): void {
     this.runtimeSnapshot = this.context ? buildAgentWorkspaceRuntimeSnapshot(this.context) : this.runtimeSnapshot;
     this.clampLocalLibrarySelection(kind);
@@ -528,7 +523,18 @@ export class AgentWorkspace {
         this.submitLocalDeleteEditor(shellPaths, editor);
         return;
       }
-      if (editor.kind === 'profile') {
+      if (editor.kind === 'learned-behavior') {
+        const created = createAgentWorkspaceLearnedBehavior(shellPaths, {
+          target: this.learnedBehaviorTarget(),
+          name: this.editorField('name'),
+          description: this.editorField('description'),
+          notes: this.editorField('notes'),
+          tags: splitList(this.editorField('tags')),
+          triggers: splitList(this.editorField('triggers')),
+          enable: isAffirmative(this.editorField('enable')),
+        });
+        this.finishLocalEditor(created.kind, created.id, created.name, 'Created');
+      } else if (editor.kind === 'profile') {
         const template = this.editorField('template');
         const templateId = template && template.toLowerCase() !== 'none' ? template : undefined;
         const profile = createAgentRuntimeProfile(shellPaths.homeDirectory, this.editorField('name'), {
@@ -572,6 +578,7 @@ export class AgentWorkspace {
             procedure: this.editorField('procedure'),
             triggers: splitList(this.editorField('triggers')),
             tags: splitList(this.editorField('tags')),
+            requirements: buildAgentWorkspaceRequirements((id) => this.editorField(id)),
             provenance: 'agent-workspace',
           });
           registry.setEnabled(updated.id, isAffirmative(this.editorField('enabled')));
@@ -584,6 +591,7 @@ export class AgentWorkspace {
           procedure: this.editorField('procedure'),
           triggers: splitList(this.editorField('triggers')),
           tags: splitList(this.editorField('tags')),
+          requirements: buildAgentWorkspaceRequirements((id) => this.editorField(id)),
           enabled: isAffirmative(this.editorField('enabled')),
           source: 'user',
           provenance: 'agent-workspace',
@@ -598,6 +606,7 @@ export class AgentWorkspace {
             steps: this.editorField('steps'),
             triggers: splitList(this.editorField('triggers')),
             tags: splitList(this.editorField('tags')),
+            requirements: buildAgentWorkspaceRequirements((id) => this.editorField(id)),
             provenance: 'agent-workspace',
           });
           registry.setEnabled(updated.id, isAffirmative(this.editorField('enabled')));
@@ -610,6 +619,7 @@ export class AgentWorkspace {
           steps: this.editorField('steps'),
           triggers: splitList(this.editorField('triggers')),
           tags: splitList(this.editorField('tags')),
+          requirements: buildAgentWorkspaceRequirements((id) => this.editorField(id)),
           enabled: isAffirmative(this.editorField('enabled')),
           source: 'user',
           provenance: 'agent-workspace',
@@ -755,7 +765,7 @@ export class AgentWorkspace {
     this.lastActionResult = {
       kind: 'refreshed',
       title: 'Created Agent profile',
-      detail: `Created isolated Agent profile ${profile.id}${starter}. Launch it with goodvibes-agent --agent-profile ${profile.id}. The current TUI session was not switched.`,
+      detail: `Created isolated Agent profile ${profile.id}${starter}. Launch it with goodvibes-agent --agent-profile ${profile.id}. The current Agent session was not switched.`,
       safety: 'safe',
     };
     this.clampSelection();

package/src/input/command-registry.ts

@@ -110,7 +110,7 @@ export interface CommandShellUiOpeners {
   focusPrompt?: () => void;
   openPolicyPanel?: () => void;
   openMcpWorkspace?: () => void;
-  openAgentWorkspace?: () => void;
+  openAgentWorkspace?: (categoryId?: string) => void;
   openSecurityPanel?: () => void;
   openKnowledgePanel?: () => void;
   openSubscriptionPanel?: () => void;

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

@@ -1,6 +1,9 @@
 import { mkdirSync } from 'node:fs';
 import { dirname } from 'node:path';
 import {
+  clearAgentRuntimeProfileSelection,
+  createAgentRuntimeProfileFromDiscovered,
+  createAgentRuntimeProfileTemplateFromDiscovered,
   createAgentRuntimeProfile,
   deleteAgentRuntimeProfile,
   exportAgentRuntimeProfileTemplate,
@@ -8,6 +11,9 @@ import {
   importAgentRuntimeProfileTemplate,
   listAgentRuntimeProfiles,
   listAgentRuntimeProfileTemplates,
+  readAgentRuntimeProfileSelection,
+  resolveAgentRuntimeProfileHome,
+  setAgentRuntimeProfileSelection,
   type AgentRuntimeProfileInfo,
   type AgentRuntimeProfileTemplateSummary,
 } from '../../agent/runtime-profile.ts';
@@ -22,6 +28,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}` : '';
@@ -41,14 +53,29 @@ function templateLine(template: AgentRuntimeProfileTemplateSummary): string {
 
 function renderProfiles(homeDirectory: string): string {
   const profiles = listAgentRuntimeProfiles(homeDirectory);
+  const selected = readAgentRuntimeProfileSelection(homeDirectory);
+  const defaultLine = selected ? `  default: ${selected.id}${selected.exists ? '' : ' (missing)'}` : '  default: (base Agent home)';
   if (profiles.length === 0) {
     return [
       'Agent Profiles',
+      defaultLine,
       '  No isolated Agent profiles yet.',
       '  Create one with /agent-profile create <name> --template <id> --yes.',
     ].join('\n');
   }
-  return ['Agent Profiles', ...profiles.map(profileLine)].join('\n');
+  return ['Agent Profiles', defaultLine, ...profiles.map(profileLine)].join('\n');
+}
+
+function renderProfileDetail(homeDirectory: string, name: string): string {
+  const profile = resolveAgentRuntimeProfileHome(homeDirectory, name);
+  const info = listAgentRuntimeProfiles(homeDirectory).find((entry) => entry.id === profile.id) ?? { ...profile, createdAt: null };
+  const starter = info.starterTemplateId ? [`  starter: ${info.starterTemplateId} (${info.starterTemplateName ?? info.starterTemplateId})`] : [];
+  return [
+    `Agent profile: ${profile.id}`,
+    `  home: ${profile.homeDirectory}`,
+    ...starter,
+    `  use: goodvibes-agent --agent-profile ${profile.id}`,
+  ].join('\n');
 }
 
 function renderTemplates(homeDirectory: string): string {
@@ -62,6 +89,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');
 }
 
@@ -83,7 +111,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 connected GoodVibes services, default wiki, or non-Agent knowledge segments.',
+    'This writes only Agent-local starter/profile state. It does not mutate connected GoodVibes host, default wiki, or non-Agent knowledge segments.',
   ].join('\n');
 }
 
@@ -108,8 +136,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|show|default|use|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);
@@ -127,6 +155,72 @@ export function registerAgentRuntimeProfileRuntimeCommands(registry: CommandRegi
           return;
         }
 
+        if (sub === 'show' || sub === 'path' || sub === 'home') {
+          const name = commandArgs[1];
+          if (!name) {
+            ctx.print('Usage: /agent-profile show <name>');
+            return;
+          }
+          ctx.print(renderProfileDetail(homeDirectory, name));
+          return;
+        }
+
+        if (sub === 'default') {
+          const target = commandArgs[1];
+          if (target === 'clear' || target === 'none' || target === 'base') {
+            if (!parsed.yes) {
+              requireYesFlag(ctx, 'clear the default Agent profile', '/agent-profile default clear --yes');
+              return;
+            }
+            clearAgentRuntimeProfileSelection(homeDirectory);
+            ctx.print('Default Agent profile cleared. Next launch uses the base Agent home unless --agent-profile is provided.');
+            return;
+          }
+          if (target) {
+            if (!parsed.yes) {
+              requireYesFlag(ctx, `set default Agent profile ${target}`, '/agent-profile default <name> --yes');
+              return;
+            }
+            const selected = setAgentRuntimeProfileSelection(homeDirectory, target);
+            ctx.print([
+              `Default Agent profile selected: ${selected.id}`,
+              `  home: ${selected.homeDirectory}`,
+              '  next launch: goodvibes-agent',
+              '  explicit override: goodvibes-agent --agent-profile <name>',
+            ].join('\n'));
+            return;
+          }
+          const selected = readAgentRuntimeProfileSelection(homeDirectory);
+          ctx.print(selected
+            ? [
+              `Default Agent profile: ${selected.id}${selected.exists ? '' : ' (missing)'}`,
+              `  home: ${selected.homeDirectory}`,
+              '  next launch: goodvibes-agent',
+            ].join('\n')
+            : 'No default Agent profile selected. Next launch uses the base Agent home.');
+          return;
+        }
+
+        if (sub === 'use' || sub === 'select' || sub === 'switch') {
+          const name = commandArgs[1];
+          if (!name) {
+            ctx.print('Usage: /agent-profile use <name> --yes');
+            return;
+          }
+          if (!parsed.yes) {
+            requireYesFlag(ctx, `set default Agent profile ${name}`, '/agent-profile use <name> --yes');
+            return;
+          }
+          const selected = setAgentRuntimeProfileSelection(homeDirectory, name);
+          ctx.print([
+            `Default Agent profile selected: ${selected.id}`,
+            `  home: ${selected.homeDirectory}`,
+            '  next launch: goodvibes-agent',
+            '  explicit override: goodvibes-agent --agent-profile <name>',
+          ].join('\n'));
+          return;
+        }
+
         if (sub === 'guide' || sub === 'author') {
           ctx.print(renderGuide(homeDirectory));
           return;
@@ -175,7 +269,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 +322,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 +368,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|show <name>|default [<name>|clear] --yes|use <name> --yes|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)}`);
       }