@pellux/goodvibes-agent 1.4.4 → 1.5.1

package/src/input/agent-workspace-profile-editors.ts

@@ -0,0 +1,155 @@
+import type { AgentWorkspaceEditorKind, AgentWorkspaceLocalEditor } from './agent-workspace-types.ts';
+
+export type AgentWorkspaceProfileEditorKind = Extract<
+  AgentWorkspaceEditorKind,
+  | 'profile-template-export'
+  | 'profile-template-import'
+  | 'profile-template-show'
+  | 'profile-show'
+  | 'profile-template-from-discovered'
+  | 'profile-from-discovered'
+  | 'profile-default'
+  | 'profile-default-clear'
+  | 'profile-delete'
+>;
+
+export function isAgentWorkspaceProfileEditorKind(kind: AgentWorkspaceEditorKind): kind is AgentWorkspaceProfileEditorKind {
+  return kind === 'profile-template-export'
+    || kind === 'profile-template-import'
+    || kind === 'profile-template-show'
+    || kind === 'profile-show'
+    || kind === 'profile-template-from-discovered'
+    || kind === 'profile-from-discovered'
+    || kind === 'profile-default'
+    || kind === 'profile-default-clear'
+    || kind === 'profile-delete';
+}
+
+export function createAgentWorkspaceProfileEditor(kind: AgentWorkspaceProfileEditorKind): AgentWorkspaceLocalEditor {
+  if (kind === 'profile-template-export') {
+    return {
+      kind,
+      mode: 'create',
+      title: 'Export Agent Starter Template',
+      selectedFieldIndex: 0,
+      message: 'Export a starter template JSON file for review and customization. Type yes on the final field to confirm.',
+      fields: [
+        { id: 'templateId', label: 'Starter id', value: '', required: true, multiline: false, hint: 'Existing starter id from /agent-profile templates.' },
+        { id: 'path', label: 'Output path', value: '', required: true, multiline: false, hint: 'Workspace-relative JSON path to write.' },
+        { id: 'confirm', label: 'Confirm', value: '', required: true, multiline: false, hint: 'Type yes to run /agent-profile template export with --yes.' },
+      ],
+    };
+  }
+  if (kind === 'profile-template-import') {
+    return {
+      kind,
+      mode: 'create',
+      title: 'Import Agent Starter Template',
+      selectedFieldIndex: 0,
+      message: 'Import a reviewed starter template JSON file into this Agent home. Type yes on the final field to confirm.',
+      fields: [
+        { id: 'path', label: 'Template path', value: '', required: true, multiline: false, hint: 'Workspace-relative JSON path to import.' },
+        { id: 'confirm', label: 'Confirm', value: '', required: true, multiline: false, hint: 'Type yes to run /agent-profile template import with --yes.' },
+      ],
+    };
+  }
+  if (kind === 'profile-template-show') {
+    return {
+      kind,
+      mode: 'create',
+      title: 'Preview Agent Starter Template',
+      selectedFieldIndex: 0,
+      message: 'Preview one built-in or local starter template before creating or exporting a profile.',
+      fields: [
+        { id: 'id', label: 'Starter id', value: '', required: true, multiline: false, hint: 'Starter template id from /agent-profile templates.' },
+      ],
+    };
+  }
+  if (kind === 'profile-show') {
+    return {
+      kind,
+      mode: 'create',
+      title: 'Show Agent Profile',
+      selectedFieldIndex: 0,
+      message: 'Show one isolated Agent profile home, starter metadata, and launch command.',
+      fields: [
+        { id: 'profile', label: 'Profile name', value: '', required: true, multiline: false, hint: 'Existing isolated Agent profile name from /agent-profile list.' },
+      ],
+    };
+  }
+  if (kind === 'profile-template-from-discovered') {
+    return {
+      kind,
+      mode: 'create',
+      title: 'Create Starter from Discovered Behavior',
+      selectedFieldIndex: 0,
+      message: 'Create an Agent-local starter template from reviewed discovered persona, skill, and routine markdown. Type yes on the final field to confirm.',
+      fields: [
+        { id: 'id', label: 'Starter id', value: '', required: true, multiline: false, hint: 'New local starter id, for example research-desk.' },
+        { id: 'name', label: 'Starter name', value: '', required: false, multiline: false, hint: 'Optional display name. Defaults to the selected persona name.' },
+        { id: 'description', label: 'Description', value: '', required: false, multiline: false, hint: 'Optional one-line summary.' },
+        { id: 'persona', label: 'Persona', value: '', required: false, multiline: false, hint: 'Optional discovered persona name/path. Blank uses the first discovered persona.' },
+        { id: 'skills', label: 'Skills', value: '', required: false, multiline: false, hint: 'all or comma-separated discovered skill names. Blank includes all.' },
+        { id: 'routines', label: 'Routines', value: '', required: false, multiline: false, hint: 'all or comma-separated discovered routine names. Blank includes all.' },
+        { id: 'replace', label: 'Replace existing', value: 'no', required: false, multiline: false, hint: 'yes/no. Existing starter ids are protected unless this is yes.' },
+        { id: 'confirm', label: 'Confirm', value: '', required: true, multiline: false, hint: 'Type yes to run /agent-profile template from-discovered with --yes.' },
+      ],
+    };
+  }
+  if (kind === 'profile-from-discovered') {
+    return {
+      kind,
+      mode: 'create',
+      title: 'Create Profile from Discovered Behavior',
+      selectedFieldIndex: 0,
+      message: 'Create a local starter template and isolated Agent profile from reviewed discovered behavior markdown. Type yes on the final field to confirm.',
+      fields: [
+        { id: 'profile', label: 'Profile name', value: '', required: true, multiline: false, hint: 'New isolated Agent profile name, for example research-desk.' },
+        { id: 'templateId', label: 'Starter id', value: '', required: false, multiline: false, hint: 'Optional local starter id. Blank uses the profile name.' },
+        { id: 'name', label: 'Starter name', value: '', required: false, multiline: false, hint: 'Optional display name for the generated starter.' },
+        { id: 'description', label: 'Description', value: '', required: false, multiline: false, hint: 'Optional one-line summary.' },
+        { id: 'persona', label: 'Persona', value: '', required: false, multiline: false, hint: 'Optional discovered persona name/path. Blank uses the first discovered persona.' },
+        { id: 'skills', label: 'Skills', value: '', required: false, multiline: false, hint: 'all or comma-separated discovered skill names. Blank includes all.' },
+        { id: 'routines', label: 'Routines', value: '', required: false, multiline: false, hint: 'all or comma-separated discovered routine names. Blank includes all.' },
+        { id: 'replace', label: 'Replace starter', value: 'no', required: false, multiline: false, hint: 'yes/no. Existing starter ids are protected unless this is yes.' },
+        { id: 'confirm', label: 'Confirm', value: '', required: true, multiline: false, hint: 'Type yes to run /agent-profile create-from-discovered with --yes.' },
+      ],
+    };
+  }
+  if (kind === 'profile-default') {
+    return {
+      kind,
+      mode: 'update',
+      title: 'Use Default Agent Profile',
+      selectedFieldIndex: 0,
+      message: 'Select which isolated Agent profile the next plain goodvibes-agent run should use. Type yes on the final field to confirm.',
+      fields: [
+        { id: 'profile', label: 'Profile name', value: '', required: true, multiline: false, hint: 'Existing isolated Agent profile name from /agent-profile list.' },
+        { id: 'confirm', label: 'Confirm', value: '', required: true, multiline: false, hint: 'Type yes to run /agent-profile use with --yes.' },
+      ],
+    };
+  }
+  if (kind === 'profile-default-clear') {
+    return {
+      kind,
+      mode: 'update',
+      title: 'Clear Default Agent Profile',
+      selectedFieldIndex: 0,
+      message: 'Return the next plain goodvibes-agent run to the base Agent home. Type yes to confirm.',
+      fields: [
+        { id: 'confirm', label: 'Confirm', value: '', required: true, multiline: false, hint: 'Type yes to run /agent-profile default clear with --yes.' },
+      ],
+    };
+  }
+  return {
+    kind,
+    mode: 'delete',
+    title: 'Delete Agent Profile',
+    selectedFieldIndex: 0,
+    message: 'Delete one isolated Agent profile home. Type yes on the final field to confirm.',
+    fields: [
+      { id: 'profile', label: 'Profile name', value: '', required: true, multiline: false, hint: 'Existing isolated Agent profile name from /agent-profile list.' },
+      { id: 'confirm', label: 'Confirm', value: '', required: true, multiline: false, hint: 'Type yes to run /agent-profile delete with --yes.' },
+    ],
+  };
+}

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

@@ -12,6 +12,12 @@ export interface AgentWorkspaceSubscriptionEditorHost {
   status: string;
   lastActionResult: AgentWorkspaceActionResult | null;
   clampSelection(): void;
+  /**
+   * Called after a successful sign-in so the host can refresh onboarding state
+   * and navigate to the next onboarding step (e.g. account-model). Optional —
+   * only available when running in ONBOARDING mode.
+   */
+  onSubscriptionLoginSuccess?(): void;
 }
 
 export type AgentWorkspaceSubscriptionFieldReader = (id: string) => string;
@@ -140,6 +146,7 @@ export async function submitAgentWorkspaceSubscriptionLoginFinishEditor(
       safety: 'safe',
     };
     host.clampSelection();
+    host.onSubscriptionLoginSuccess?.();
   } catch (error) {
     const detail = error instanceof Error ? error.message : String(error);
     host.localEditor = { ...editor, message: detail };

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

@@ -151,6 +151,8 @@ export type AgentWorkspaceEditorKind =
   | 'persona-discovery-import'
   | 'routine-discovery-import'
   | 'skill-discovery-import'
+  | 'skill-standard-import'
+  | 'skill-standard-export'
   | 'learned-behavior'
   | 'profile-template-export'
   | 'profile-template-import'
@@ -334,7 +336,7 @@ export interface AgentWorkspaceActionSearchResult {
 export type AgentWorkspaceCommandDispatcher = (command: string, behavior?: 'inline' | 'compose' | 'exit') => void;
 export type AgentWorkspacePromptDispatcher = (prompt: string) => void;
 
-export type AgentWorkspaceActionResultKind = 'guidance' | 'blocked' | 'dispatched' | 'refreshed' | 'error';
+export type AgentWorkspaceActionResultKind = 'guidance' | 'blocked' | 'dispatched' | 'refreshed' | 'error' | 'recap';
 
 export interface AgentWorkspaceActionResult {
   readonly kind: AgentWorkspaceActionResultKind;
@@ -342,6 +344,8 @@ export interface AgentWorkspaceActionResult {
   readonly detail: string;
   readonly command?: string;
   readonly safety?: AgentWorkspaceAction['safety'];
+  /** Lines to display when kind is 'recap'. */
+  readonly lines?: readonly string[];
 }
 
 export interface AgentWorkspaceLocalLibraryItem {

package/src/input/agent-workspace.ts

@@ -24,7 +24,9 @@ import { buildAgentWorkspaceRuntimeSnapshot } from './agent-workspace-snapshot.t
 import { submitAgentWorkspaceSubscriptionLoginFinishEditor, submitAgentWorkspaceSubscriptionLoginStartEditor, submitAgentWorkspaceSubscriptionLogoutEditor } from './agent-workspace-subscription-editor.ts';
 import type { AgentWorkspaceAction, AgentWorkspaceActionResult, AgentWorkspaceActionSearchResult, AgentWorkspaceCategory, AgentWorkspaceCategoryGroup, AgentWorkspaceCommandDispatcher, AgentWorkspaceEditorField, AgentWorkspaceFocusPane, AgentWorkspaceLocalEditor, AgentWorkspaceLocalEditorKind, AgentWorkspaceLocalLibraryItem, AgentWorkspaceLocalOperation, AgentWorkspacePromptDispatcher, AgentWorkspaceRuntimeSnapshot } from './agent-workspace-types.ts';
 import { ONBOARDING_COMPLETE_SYNTHETIC_ACTION, shouldShowOnboardingFinishFooter } from './agent-workspace-onboarding-finish.ts';
-import { writeOnboardingCheckMarker, writeOnboardingCompletionMarker } from '../runtime/onboarding/index.ts';
+import { completeOnboardingAction, onSubscriptionLoginSuccessAction } from './agent-workspace-onboarding-actions.ts';
+import { computeOnboardingStateFromSnapshot, deriveOnboardingEntry, updateRevealedOnboardingCategories } from './agent-workspace-onboarding-state.ts';
+import type { OnboardingState } from '../runtime/onboarding/onboarding-state.ts';
 
 export type { AgentWorkspaceChannelRisk, AgentWorkspaceChannelStatus } from './agent-workspace-channels.ts';
 export type { AgentWorkspaceAction, AgentWorkspaceActionResult, AgentWorkspaceActionSearchResult, AgentWorkspaceCategory, AgentWorkspaceCategoryId, AgentWorkspaceCommandDispatcher, AgentWorkspaceEditorField, AgentWorkspaceFocusPane, AgentWorkspaceLocalEditor, AgentWorkspaceLocalEditorKind, AgentWorkspaceLocalLibraryItem, AgentWorkspaceLocalOperation, AgentWorkspacePromptDispatcher, AgentWorkspaceRuntimeSnapshot } from './agent-workspace-types.ts';
@@ -48,13 +50,20 @@ export class AgentWorkspace {
   private dispatchCommand: AgentWorkspaceCommandDispatcher | null = null;
   private dispatchPrompt: AgentWorkspacePromptDispatcher | null = null;
   private _onlyGroup: AgentWorkspaceCategoryGroup | null = null;
+  private _onboardingState: OnboardingState | null = null;
+  private _revealedOnboardingCategoryIds = new Set<string>(); // monotonic reveal set
+  private _awaitingRecapDismiss = false; // true while showing recap before final close
 
   open(context: CommandContext, dispatchCommand: AgentWorkspaceCommandDispatcher, categoryId?: string, dispatchPrompt?: AgentWorkspacePromptDispatcher, onlyGroup?: AgentWorkspaceCategoryGroup): void {
     this.context = context;
     this.dispatchCommand = dispatchCommand;
     this.dispatchPrompt = dispatchPrompt ?? null;
     this._onlyGroup = onlyGroup ?? null;
+    this._awaitingRecapDismiss = false;
     this.runtimeSnapshot = buildAgentWorkspaceRuntimeSnapshot(context);
+    const shellPaths = context.workspace?.shellPaths;
+    this._onboardingState = computeOnboardingStateFromSnapshot(this.runtimeSnapshot, shellPaths);
+    if (this._onboardingState) updateRevealedOnboardingCategories(this._onboardingState, this._revealedOnboardingCategoryIds);
     this.active = true;
     this.focusPane = 'actions';
     this.status = 'Ready. Choose an operator flow; ordinary assistant work stays in the main conversation.';
@@ -75,6 +84,14 @@ export class AgentWorkspace {
         safety: 'safe',
       };
     }
+    if (onlyGroup === 'ONBOARDING' && this._onboardingState) {
+      const entry = deriveOnboardingEntry(this._onboardingState);
+      this.status = entry.status;
+      if (entry.categoryId) {
+        const idx = this.categories.findIndex((c) => c.id === entry.categoryId);
+        if (idx >= 0) this.selectedCategoryIndex = idx;
+      }
+    }
     this.clampSelection();
   }
 
@@ -89,9 +106,21 @@ export class AgentWorkspace {
     this.actionSearchActive = false;
     this.actionSearchQuery = '';
     this._onlyGroup = null;
+    this._onboardingState = null;
+    this._awaitingRecapDismiss = false;
   }
 
   get categories(): readonly AgentWorkspaceCategory[] {
+    if (this._onlyGroup === 'ONBOARDING') {
+      // Pure read — reveal set is updated at every _onboardingState assignment
+      // (open, onSubscriptionLoginSuccess), not here. Recompute is O(categories)
+      // and intentionally simple; the list is small and no caching is needed.
+      const onboarding = AGENT_WORKSPACE_CATEGORIES.filter((c) => c.group === 'ONBOARDING');
+      if (this._onboardingState) {
+        return onboarding.filter((c) => this._revealedOnboardingCategoryIds.has(c.id));
+      }
+      return onboarding;
+    }
     if (this._onlyGroup) {
       return AGENT_WORKSPACE_CATEGORIES.filter((category) => category.group === this._onlyGroup);
     }
@@ -105,7 +134,7 @@ export class AgentWorkspace {
   get actions(): readonly AgentWorkspaceAction[] {
     if (this.actionSearchActive) return this.actionSearchResults.map((result) => result.action);
     const base = this.selectedCategory.actions.filter((action) => isAgentWorkspaceActionVisible(this.context, action));
-    if (shouldShowOnboardingFinishFooter(this.selectedCategory, base)) {
+    if (shouldShowOnboardingFinishFooter(this.selectedCategory, base, this._onlyGroup === 'ONBOARDING' ? this._onboardingState?.readyToChat : undefined)) {
       return [...base, ONBOARDING_COMPLETE_SYNTHETIC_ACTION];
     }
     return base;
@@ -169,21 +198,10 @@ export class AgentWorkspace {
     this.focusPane = this.focusPane === 'categories' ? 'actions' : 'categories';
   }
 
-  moveUp(): void {
-    moveAgentWorkspaceSelection(this, -1);
-  }
-
-  moveDown(): void {
-    moveAgentWorkspaceSelection(this, 1);
-  }
-
-  jumpHome(): void {
-    jumpAgentWorkspaceSelection(this, 'home');
-  }
-
-  jumpEnd(): void {
-    jumpAgentWorkspaceSelection(this, 'end');
-  }
+  moveUp(): void { moveAgentWorkspaceSelection(this, -1); }
+  moveDown(): void { moveAgentWorkspaceSelection(this, 1); }
+  jumpHome(): void { jumpAgentWorkspaceSelection(this, 'home'); }
+  jumpEnd(): void { jumpAgentWorkspaceSelection(this, 'end'); }
 
   refreshRuntimeSnapshot(): void {
     if (!this.context) {
@@ -306,6 +324,7 @@ export class AgentWorkspace {
     clampAgentWorkspaceLocalLibrarySelection(this.runtimeSnapshot, this.selectedLibraryItemIndexes, 'persona');
     clampAgentWorkspaceLocalLibrarySelection(this.runtimeSnapshot, this.selectedLibraryItemIndexes, 'skill');
     clampAgentWorkspaceLocalLibrarySelection(this.runtimeSnapshot, this.selectedLibraryItemIndexes, 'routine');
+    clampAgentWorkspaceLocalLibrarySelection(this.runtimeSnapshot, this.selectedLibraryItemIndexes, 'profile');
   }
 
   moveLocalLibraryItemSelection(kind: AgentWorkspaceLocalEditorKind, delta: number): void {
@@ -323,30 +342,37 @@ export class AgentWorkspace {
   }
 
   completeOnboarding(): void {
-    const shellPaths = this.context?.workspace?.shellPaths;
-    if (!shellPaths) {
-      this.status = 'Cannot complete onboarding without Agent shell paths.';
-      this.lastActionResult = {
-        kind: 'error',
-        title: 'Onboarding completion unavailable',
-        detail: 'The Agent workspace cannot locate the user onboarding completion marker path for this runtime.',
-        safety: 'safe',
-      };
-      return;
-    }
+    const result = completeOnboardingAction({
+      awaitingRecapDismiss: this._awaitingRecapDismiss,
+      runtimeSnapshot: this.runtimeSnapshot,
+      shellPaths: this.context?.workspace?.shellPaths,
+      dismissAgentWorkspace: this.context?.dismissAgentWorkspace,
+      close: () => this.close(),
+    });
+    if (result.dismissed) return;
+    this._awaitingRecapDismiss = result.awaitingRecapDismiss;
+    this.status = result.status;
+    this.lastActionResult = result.lastActionResult;
+  }
 
-    try {
-      const marker = { scope: 'user', source: 'wizard', mode: 'new', workspaceRoot: shellPaths.workingDirectory } as const;
-      writeOnboardingCheckMarker(shellPaths, marker);
-      writeOnboardingCompletionMarker(shellPaths, marker);
-      this.status = 'Onboarding applied and closed.';
-      this.lastActionResult = { kind: 'refreshed', title: 'Onboarding complete', detail: 'Saved the user onboarding completion marker. Future normal launches start in the main conversation.', safety: 'safe' };
-      if (!this.context?.dismissAgentWorkspace?.()) this.close();
-    } catch (error) {
-      const detail = error instanceof Error ? error.message : String(error);
-      this.status = 'Onboarding completion failed.';
-      this.lastActionResult = { kind: 'error', title: 'Onboarding completion failed', detail, safety: 'safe' };
+  onSubscriptionLoginSuccess(): void {
+    const result = onSubscriptionLoginSuccessAction({
+      onlyGroup: this._onlyGroup,
+      runtimeSnapshot: this.runtimeSnapshot,
+      shellPaths: this.context?.workspace?.shellPaths,
+    });
+    if (this._onlyGroup !== 'ONBOARDING') return;
+    // Update _onboardingState and reveal set FIRST so that this.categories
+    // reflects any newly-unlocked lane (e.g. account-model after sign-in)
+    // before we try to resolve the target index against the fresh list.
+    this._onboardingState = result.onboardingState;
+    if (!result.onboardingState) return;
+    if (this._onboardingState) updateRevealedOnboardingCategories(this._onboardingState, this._revealedOnboardingCategoryIds);
+    if (result.targetCategoryId) {
+      const idx = this.categories.findIndex((c) => c.id === result.targetCategoryId);
+      if (idx >= 0) this.selectedCategoryIndex = idx;
     }
+    this.status = result.status;
   }
 
   openModelPickerAction(action: AgentWorkspaceAction, requestRender?: () => void): void {

package/src/input/command-registry.ts

@@ -8,7 +8,6 @@ import type { ProcessManager } from '@pellux/goodvibes-sdk/platform/tools';
 import type { PermissionRequestHandler } from '@pellux/goodvibes-sdk/platform/permissions';
 import type { SelectionItem, SelectionResult, SelectionAction } from './selection-modal.ts';
 import type { FileUndoManager } from '@pellux/goodvibes-sdk/platform/state';
-import type { PanelManager } from '../panels/panel-manager.ts';
 import type { KeybindingsManager } from './keybindings.ts';
 import type { KnowledgeApi } from '@pellux/goodvibes-sdk/platform/knowledge';
 import type { HookApi } from '@pellux/goodvibes-sdk/platform/hooks';
@@ -124,9 +123,7 @@ export interface CommandShellUiOpeners {
   openProfilePicker?: () => void;
   openShortcutsOverlay?: () => void;
   getScrollTop?: () => number;
-  openPanelPicker?: () => void;
-  showPanel?: (panelId: string, pane?: 'top' | 'bottom') => void;
-  focusPanels?: () => void;
+  openWorkspacePicker?: () => void;
   focusPrompt?: () => void;
   openMcpWorkspace?: () => void;
   openAgentWorkspace?: (categoryId?: string) => void;
@@ -134,6 +131,7 @@ export interface CommandShellUiOpeners {
   openSecurityPanel?: () => void;
   openKnowledgePanel?: () => void;
   openSubscriptionPanel?: () => void;
+  toggleActivitySidebar?: () => void;
 }
 
 export interface CommandSessionServices {
@@ -159,7 +157,6 @@ export interface CommandProviderServices {
 export interface CommandWorkspaceUiServices {
   keybindingsManager?: KeybindingsManager;
   fileUndoManager?: FileUndoManager;
-  panelManager?: PanelManager;
   processManager?: ProcessManager;
   profileManager?: import('@pellux/goodvibes-sdk/platform/profiles').ProfileManager;
   bookmarkManager?: import('@pellux/goodvibes-sdk/platform/bookmarks').BookmarkManager;
@@ -243,6 +240,13 @@ export interface SlashCommand {
   usage?: string;
   /** Short inline argument hint shown after cursor in dim grey, e.g. "[name]". Falls back to usage if not set. */
   argsHint?: string;
+  /**
+   * Hidden commands still run when typed, but stay out of fuzzy autocomplete
+   * suggestions. They surface in autocomplete on an exact name or alias match.
+   * The /help overlay also filters them. The /commands slash command lists
+   * all commands including hidden ones, labeled "(hidden)".
+   */
+  hidden?: boolean;
   /** The function executed when the command is invoked. */
   handler: (args: string[], context: CommandContext) => void | Promise<void>;
 }
@@ -286,6 +290,11 @@ export class CommandRegistry {
     return Array.from(this.commands.values());
   }
 
+  /** Commands that should appear in autocomplete and /help listings. */
+  getVisible(): SlashCommand[] {
+    return this.getAll().filter((command) => !command.hidden);
+  }
+
   /**
    * list - Compatibility alias for the simpler SDK registry surface.
    */
@@ -310,6 +319,10 @@ export class CommandRegistry {
         if (score > bestScore) bestScore = score;
       }
 
+      // Hidden commands stay out of suggestions until the user types the
+      // exact name or alias — they still execute normally.
+      if (cmd.hidden && !names.map((n) => n.toLowerCase()).includes(q)) continue;
+
       if (bestScore > 0 || q === '') {
         results.push({ command: cmd, score: q === '' ? 1 : bestScore });
       }

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

@@ -139,6 +139,7 @@ export function registerAgentRuntimeProfileRuntimeCommands(registry: CommandRegi
     name: 'agent-profile',
     aliases: ['runtime-profile', 'agent-profiles'],
     description: 'Manage isolated Agent profiles and starter templates',
+    hidden: true,
     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);
@@ -244,7 +245,7 @@ export function registerAgentRuntimeProfileRuntimeCommands(registry: CommandRegi
             const templateId = commandArgs[2];
             const pathArg = commandArgs[3];
             if (!templateId || !pathArg) {
-            ctx.print('Usage: /agent-profile template export <id> <path> [--include-vibe] --yes');
+              ctx.print('Usage: /agent-profile template export <id> <path> [--include-vibe] --yes');
               return;
             }
             if (!parsed.yes) {

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

@@ -1,3 +1,4 @@
+import { readFileSync } from 'node:fs';
 import {
   AgentSkillRegistry,
   buildAgentSkillRequirements,
@@ -8,6 +9,7 @@ import {
   type AgentSkillRecord,
 } from '../../agent/skill-registry.ts';
 import { discoverSkills, type SkillRecord } from '../../agent/skill-discovery.ts';
+import { parseSkillStandardMarkdown } from '../../agent/skill-standard.ts';
 import { formatAgentRecordOrigin, formatAgentRecordReviewState } from '../../agent/record-labels.ts';
 import type { CommandContext, CommandRegistry } from '../command-registry.ts';
 import { parseAgentLocalLibraryArgs, type ParsedAgentLocalLibraryArgs } from './agent-local-library-args.ts';
@@ -137,7 +139,7 @@ async function importDiscoveredSkill(args: readonly string[], ctx: CommandContex
   const parsed = parseSkillArgs(args);
   const name = parsed.rest.join(' ').trim();
   if (!name) {
-    ctx.print('Usage: /skills import-discovered <name> [--enabled] --yes');
+    ctx.print('Usage: /skills import-discovered <name> --yes\n  Note: discovered skills import disabled; review then enable via /skills enable <name>.');
     return;
   }
   const discovered = findDiscoveredSkill(await discoverSkills(requireShellPaths(ctx)), name);
@@ -167,11 +169,14 @@ async function importDiscoveredSkill(args: readonly string[], ctx: CommandContex
       env: frontmatterAnyList(discovered, ['requiresEnv', 'requires-env', 'requires_env']),
       commands: frontmatterAnyList(discovered, ['requiresCommands', 'requires-commands', 'requires_commands', 'commands']),
     }),
-    enabled: parsed.flags.get('enabled') === 'true',
+    enabled: false,
     source: 'imported',
     provenance: `Imported file (${discovered.origin}): ${discovered.path}`,
   });
-  ctx.print(formatSkillReceipt('Imported Agent skill', skill, [`  enabled ${skill.enabled ? 'yes' : 'no'}`]));
+  ctx.print(formatSkillReceipt('Imported Agent skill', skill, [
+    '  enabled no — imported disabled (review it, then enable it)',
+    '  review pending',
+  ]));
 }
 
 function renderBundleList(title: string, registry: AgentSkillRegistry, bundles: readonly AgentSkillBundleRecord[], emptyMessage?: string): string {
@@ -377,6 +382,57 @@ export async function runAgentSkillsRuntimeCommand(args: readonly string[], ctx:
       await importDiscoveredSkill(args.slice(1), ctx, skillRegistry);
       return;
     }
+    if (sub === 'import-standard') {
+      const parsed = parseSkillArgs(args.slice(1));
+      const filePath = parsed.rest[0];
+      if (!filePath) {
+        ctx.print('Usage: /skills import-standard <path/to/SKILL.md> --yes');
+        return;
+      }
+      if (!parsed.yes) {
+        ctx.print([
+          'Agent skill standard import preview',
+          `  path ${filePath}`,
+          '  next rerun with --yes to import into the Agent-local skill registry',
+        ].join('\n'));
+        return;
+      }
+      const content = readFileSync(filePath, 'utf-8');
+      const parseResult = parseSkillStandardMarkdown(content);
+      if ('error' in parseResult) {
+        ctx.print(`Skill standard import rejected: ${parseResult.error}`);
+        return;
+      }
+      const skill = skillRegistry.importFromStandard(content);
+      ctx.print(formatSkillReceipt('Imported shared skill', skill, [`  source ${filePath}`, `  review-state ${skill.reviewState}`]));
+      return;
+    }
+    if (sub === 'export-standard') {
+      const parsed = parseSkillArgs(args.slice(1));
+      const skillId = parsed.rest[0];
+      const destDir = parsed.rest[1];
+      if (!skillId || !destDir) {
+        ctx.print('Usage: /skills export-standard <id> <dest-directory> --yes');
+        return;
+      }
+      if (!parsed.yes) {
+        const skill = skillRegistry.get(skillId);
+        if (!skill) {
+          ctx.print(`Unknown Agent skill ${skillId}`);
+          return;
+        }
+        ctx.print([
+          'Agent skill standard export preview',
+          `  skill ${skill.id} (${skill.name})`,
+          `  dest ${destDir}/${skill.name.toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/^-|-$/g, '')}/SKILL.md`,
+          '  next rerun with --yes to write the file',
+        ].join('\n'));
+        return;
+      }
+      const written = skillRegistry.exportToStandard(skillId, destDir);
+      ctx.print(`Exported skill to ${written}`);
+      return;
+    }
     if (sub === 'list' || sub === 'open') {
       ctx.print(renderList('Agent Skills', skillRegistry, skillRegistry.list()));
       return;
@@ -506,6 +562,7 @@ export function registerAgentSkillsRuntimeCommands(registry: CommandRegistry): v
     name: 'skills',
     aliases: ['skill', 'agent-skills', 'askills', 'local-skills'],
     description: 'Manage Agent-local skills',
+    hidden: true,
     usage: '[list|enabled|attention|discover|import-discovered <name> --yes|search <query>|show <id>|create --name <name> --description <summary> --procedure <steps> [--requires-env A,B] [--requires-command gh,jq]|update <id> [--name ...] [--description ...] [--procedure ...]|enable <id>|disable <id>|review <id>|stale <id> <reason...>|delete <id> --yes|bundle ...]',
     handler: runAgentSkillsRuntimeCommand,
   });