@pellux/goodvibes-agent 0.1.2 → 0.1.4

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

@@ -0,0 +1,216 @@
+import { AgentSkillRegistry, type AgentSkillRecord } from '../../agent/skill-registry.ts';
+import type { CommandContext, CommandRegistry } from '../command-registry.ts';
+import { requireShellPaths } from './runtime-services.ts';
+
+interface ParsedSkillArgs {
+  readonly rest: readonly string[];
+  readonly flags: ReadonlyMap<string, string>;
+  readonly yes: boolean;
+}
+
+function parseSkillArgs(args: readonly string[]): ParsedSkillArgs {
+  const flags = new Map<string, string>();
+  const rest: string[] = [];
+  let yes = false;
+  for (let index = 0; index < args.length; index += 1) {
+    const token = args[index] ?? '';
+    if (token === '--yes') {
+      yes = true;
+      continue;
+    }
+    if (token.startsWith('--')) {
+      const key = token.slice(2);
+      const next = args[index + 1];
+      if (next !== undefined && !next.startsWith('--')) {
+        flags.set(key, next);
+        index += 1;
+      } else {
+        flags.set(key, 'true');
+      }
+      continue;
+    }
+    rest.push(token);
+  }
+  return { rest, flags, yes };
+}
+
+function splitList(value: string | undefined): readonly string[] {
+  if (!value) return [];
+  return value.split(',').map((entry) => entry.trim()).filter(Boolean);
+}
+
+function registryFromContext(ctx: CommandContext): AgentSkillRegistry {
+  return AgentSkillRegistry.fromShellPaths(requireShellPaths(ctx));
+}
+
+function requiredFlag(flags: ReadonlyMap<string, string>, key: string): string {
+  const value = flags.get(key)?.trim();
+  if (!value) throw new Error(`Missing --${key}.`);
+  return value;
+}
+
+function summarizeSkill(skill: AgentSkillRecord): string {
+  const enabled = skill.enabled ? 'enabled' : 'disabled';
+  const tags = skill.tags.length > 0 ? ` tags=${skill.tags.join(',')}` : '';
+  return `  ${skill.id}  ${enabled}  ${skill.reviewState}  ${skill.name} - ${skill.description}${tags}`;
+}
+
+function renderList(title: string, registry: AgentSkillRegistry, skills: readonly AgentSkillRecord[]): string {
+  const snapshot = registry.snapshot();
+  if (skills.length === 0) {
+    return `${title}\n  No local Agent skills yet. Create one with /agent-skills create --name <name> --description <summary> --procedure <steps>.`;
+  }
+  return [
+    `${title} (${skills.length})`,
+    `  store: ${snapshot.path}`,
+    `  enabled: ${snapshot.enabledSkills.length}`,
+    ...skills.map(summarizeSkill),
+  ].join('\n');
+}
+
+function renderSkill(skill: AgentSkillRecord): string {
+  return [
+    `Skill ${skill.name}`,
+    `  id: ${skill.id}`,
+    `  enabled: ${skill.enabled ? 'yes' : 'no'}`,
+    `  review: ${skill.reviewState}`,
+    `  source: ${skill.source}`,
+    `  provenance: ${skill.provenance}`,
+    `  tags: ${skill.tags.join(', ') || '(none)'}`,
+    `  triggers: ${skill.triggers.join(', ') || '(manual)'}`,
+    `  created: ${skill.createdAt}`,
+    `  updated: ${skill.updatedAt}`,
+    skill.staleReason ? `  stale reason: ${skill.staleReason}` : '',
+    '',
+    skill.description,
+    '',
+    skill.procedure,
+  ].filter(Boolean).join('\n');
+}
+
+function printError(ctx: CommandContext, error: unknown): void {
+  ctx.print(`Error: ${error instanceof Error ? error.message : String(error)}`);
+}
+
+export async function runAgentSkillsRuntimeCommand(args: readonly string[], ctx: CommandContext): Promise<void> {
+  const sub = (args[0] ?? 'list').toLowerCase();
+  const skillRegistry = registryFromContext(ctx);
+  try {
+    if (sub === 'list' || sub === 'open') {
+      ctx.print(renderList('Agent Skills', skillRegistry, skillRegistry.list()));
+      return;
+    }
+    if (sub === 'enabled') {
+      const snapshot = skillRegistry.snapshot();
+      ctx.print(renderList('Enabled Agent Skills', skillRegistry, snapshot.enabledSkills));
+      return;
+    }
+    if (sub === 'search') {
+      const query = args.slice(1).join(' ').trim();
+      ctx.print(renderList(query ? `Agent Skills matching "${query}"` : 'Agent Skills', skillRegistry, skillRegistry.search(query)));
+      return;
+    }
+    if (sub === 'show') {
+      const id = args[1];
+      if (!id) {
+        ctx.print('Usage: /agent-skills show <id>');
+        return;
+      }
+      const skill = skillRegistry.get(id);
+      ctx.print(skill ? renderSkill(skill) : `Unknown Agent skill: ${id}`);
+      return;
+    }
+    if (sub === 'create') {
+      const parsed = parseSkillArgs(args.slice(1));
+      const procedure = parsed.flags.get('procedure')?.trim() || parsed.rest.join(' ').trim();
+      const skill = skillRegistry.create({
+        name: requiredFlag(parsed.flags, 'name'),
+        description: requiredFlag(parsed.flags, 'description'),
+        procedure,
+        triggers: splitList(parsed.flags.get('triggers')),
+        tags: splitList(parsed.flags.get('tags')),
+        enabled: parsed.flags.get('enabled') === 'true',
+        source: 'user',
+        provenance: 'slash-command',
+      });
+      ctx.print(`Created Agent skill ${skill.id}: ${skill.name}`);
+      return;
+    }
+    if (sub === 'update') {
+      const id = args[1];
+      if (!id) {
+        ctx.print('Usage: /agent-skills update <id> [--name ...] [--description ...] [--procedure ...]');
+        return;
+      }
+      const parsed = parseSkillArgs(args.slice(2));
+      const updated = skillRegistry.update(id, {
+        name: parsed.flags.get('name'),
+        description: parsed.flags.get('description'),
+        procedure: parsed.flags.get('procedure'),
+        triggers: parsed.flags.has('triggers') ? splitList(parsed.flags.get('triggers')) : undefined,
+        tags: parsed.flags.has('tags') ? splitList(parsed.flags.get('tags')) : undefined,
+        provenance: 'slash-command',
+      });
+      ctx.print(`Updated Agent skill ${updated.id}: ${updated.name}`);
+      return;
+    }
+    if (sub === 'enable' || sub === 'disable') {
+      const id = args[1];
+      if (!id) {
+        ctx.print(`Usage: /agent-skills ${sub} <id>`);
+        return;
+      }
+      const skill = skillRegistry.setEnabled(id, sub === 'enable');
+      ctx.print(`${sub === 'enable' ? 'Enabled' : 'Disabled'} Agent skill ${skill.id}: ${skill.name}`);
+      return;
+    }
+    if (sub === 'review') {
+      const id = args[1];
+      if (!id) {
+        ctx.print('Usage: /agent-skills review <id>');
+        return;
+      }
+      const skill = skillRegistry.markReviewed(id);
+      ctx.print(`Reviewed Agent skill ${skill.id}.`);
+      return;
+    }
+    if (sub === 'stale') {
+      const id = args[1];
+      if (!id) {
+        ctx.print('Usage: /agent-skills stale <id> <reason...>');
+        return;
+      }
+      const skill = skillRegistry.markStale(id, args.slice(2).join(' '));
+      ctx.print(`Marked Agent skill ${skill.id} stale.`);
+      return;
+    }
+    if (sub === 'delete' || sub === 'remove') {
+      const parsed = parseSkillArgs(args.slice(1));
+      const id = parsed.rest[0];
+      if (!id) {
+        ctx.print('Usage: /agent-skills delete <id> --yes');
+        return;
+      }
+      if (!parsed.yes) {
+        ctx.print(`Refusing to delete Agent skill ${id} without --yes.`);
+        return;
+      }
+      const removed = skillRegistry.deleteSkill(id);
+      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]');
+  } catch (error) {
+    printError(ctx, error);
+  }
+}
+
+export function registerAgentSkillsRuntimeCommands(registry: CommandRegistry): void {
+  registry.register({
+    name: 'agent-skills',
+    aliases: ['askills', 'local-skills'],
+    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]',
+    handler: runAgentSkillsRuntimeCommand,
+  });
+}

package/src/input/commands/knowledge.ts

@@ -8,10 +8,10 @@ type KnowledgeAskInput = Parameters<KnowledgeService['ask']>[0];
 type KnowledgeAskResult = Awaited<ReturnType<KnowledgeService['ask']>>;
 type KnowledgeAskMode = NonNullable<KnowledgeAskInput['mode']>;
 
-function requireKnowledgeApi(context: CommandContext) {
-  const knowledgeApi = context.clients?.knowledgeApi;
+function requireAgentKnowledgeApi(context: CommandContext) {
+  const knowledgeApi = context.clients?.agentKnowledgeApi;
   if (!knowledgeApi) {
-    context.print('[knowledge] Knowledge API is not available in this runtime.');
+    context.print('[knowledge] Agent Knowledge API is not available in this runtime. Refusing to use default Knowledge/Wiki or HomeGraph fallback.');
     return null;
   }
   return knowledgeApi;
@@ -57,14 +57,11 @@ function positionalArgs(args: string[], valuedFlags: readonly string[] = []): st
   });
 }
 
-function requireKnowledgeAsk(context: CommandContext): ((input: KnowledgeAskInput) => Promise<KnowledgeAskResult>) | null {
-  const serviceAsk = context.extensions.knowledgeService?.ask?.bind(context.extensions.knowledgeService);
+function requireAgentKnowledgeAsk(context: CommandContext): ((input: KnowledgeAskInput) => Promise<KnowledgeAskResult>) | null {
+  const serviceAsk = context.extensions.agentKnowledgeService?.ask?.bind(context.extensions.agentKnowledgeService);
   if (serviceAsk) return serviceAsk;
 
-  const clientAsk = (context.clients?.knowledgeApi as unknown as { ask?: (input: KnowledgeAskInput) => Promise<KnowledgeAskResult> } | undefined)?.ask;
-  if (clientAsk) return clientAsk;
-
-  context.print('[knowledge] Knowledge ask is not available in this runtime.');
+  context.print('[knowledge] Agent Knowledge ask is not available in this runtime. Refusing to use default Knowledge/Wiki or HomeGraph fallback.');
   return null;
 }
 
@@ -132,11 +129,11 @@ function renderKnowledgeAskResult(result: KnowledgeAskResult): string {
 export const knowledgeCommand: SlashCommand = {
   name: 'knowledge',
   aliases: ['know', 'kb'],
-  description: 'Structured knowledge graph: ingest URLs/bookmarks, inspect issues, and build compact prompt packets.',
+  description: 'Agent Knowledge/Wiki: isolated Agent-owned sources, graph, review queue, and compact prompt packets.',
   usage: '<subcommand> [args]',
   argsHint: 'status|ask|ingest-url|import-bookmarks|import-urls|list|search|get|queue|review-issue|candidates|reports|schedules|lint|packet|explain|reindex|consolidate',
   handler: async (args: string[], context: CommandContext): Promise<void> => {
-    const knowledge = requireKnowledgeApi(context);
+    const knowledge = requireAgentKnowledgeApi(context);
     if (!knowledge) {
       return;
     }
@@ -149,12 +146,16 @@ export const knowledgeCommand: SlashCommand = {
 
     switch (sub) {
       case 'ask': {
-        const ask = requireKnowledgeAsk(context);
+        const ask = requireAgentKnowledgeAsk(context);
         if (!ask) return;
-        const valuedFlags = ['--space', '--knowledge-space', '--limit', '--mode'];
+        const valuedFlags = ['--limit', '--mode'];
         const query = positionalArgs(rest, valuedFlags).join(' ').trim();
         if (!query) {
-          context.print('[knowledge] Usage: /knowledge ask <query> [--space <knowledgeSpaceId>] [--limit <n>] [--mode <concise|standard|detailed>]');
+          context.print('[knowledge] Usage: /knowledge ask <query> [--limit <n>] [--mode <concise|standard|detailed>]');
+          return;
+        }
+        if (readFlag(rest, '--space') || readFlag(rest, '--knowledge-space')) {
+          context.print('[knowledge] Agent Knowledge is isolated. --space/--knowledge-space is not accepted because Agent must not fall back to default Knowledge/Wiki or HomeGraph.');
           return;
         }
         const requestedMode = readFlag(rest, '--mode') as KnowledgeAskMode | undefined;
@@ -163,7 +164,6 @@ export const knowledgeCommand: SlashCommand = {
           : 'standard';
         const result = await ask({
           query,
-          knowledgeSpaceId: readFlag(rest, '--space') ?? readFlag(rest, '--knowledge-space'),
           limit: readPositiveIntFlag(rest, '--limit', 10),
           mode,
           includeSources: true,
@@ -177,7 +177,7 @@ export const knowledgeCommand: SlashCommand = {
       case 'status': {
         const status = await knowledge.status.get();
         context.print([
-          '[knowledge] Structured knowledge status',
+          '[knowledge] Agent Knowledge status',
           `  ready: ${status.ready ? 'yes' : 'no'}`,
           `  storage: ${status.storagePath}`,
           `  sources: ${status.sourceCount}`,
@@ -385,7 +385,7 @@ export const knowledgeCommand: SlashCommand = {
           const result = await knowledge.graph.issues.review({
             issueId,
             action: action as KnowledgeReviewAction,
-            reviewer: readFlag(rest, '--reviewer') ?? 'tui',
+            reviewer: readFlag(rest, '--reviewer') ?? 'agent',
             ...(value ? { value } : {}),
           });
           context.print([
@@ -508,7 +508,7 @@ export const knowledgeCommand: SlashCommand = {
         context.print([
           'Usage: /knowledge <subcommand>',
           '  status',
-          '  ask <query> [--space <knowledgeSpaceId>] [--limit <n>] [--mode <concise|standard|detailed>]',
+          '  ask <query> [--limit <n>] [--mode <concise|standard|detailed>]',
           '  ingest-url <url> [--title <title>] [--tags <a,b>] [--folder <path>]',
           '  import-bookmarks <path>',
           '  import-urls <path>',

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

@@ -0,0 +1,219 @@
+import { AgentPersonaRegistry, type AgentPersonaRecord } from '../../agent/persona-registry.ts';
+import type { CommandContext, CommandRegistry } from '../command-registry.ts';
+import { requireShellPaths } from './runtime-services.ts';
+
+interface ParsedPersonaArgs {
+  readonly rest: readonly string[];
+  readonly flags: ReadonlyMap<string, string>;
+  readonly yes: boolean;
+}
+
+function parsePersonaArgs(args: readonly string[]): ParsedPersonaArgs {
+  const flags = new Map<string, string>();
+  const rest: string[] = [];
+  let yes = false;
+  for (let index = 0; index < args.length; index += 1) {
+    const token = args[index] ?? '';
+    if (token === '--yes') {
+      yes = true;
+      continue;
+    }
+    if (token.startsWith('--')) {
+      const key = token.slice(2);
+      const next = args[index + 1];
+      if (next !== undefined && !next.startsWith('--')) {
+        flags.set(key, next);
+        index += 1;
+      } else {
+        flags.set(key, 'true');
+      }
+      continue;
+    }
+    rest.push(token);
+  }
+  return { rest, flags, yes };
+}
+
+function splitList(value: string | undefined): readonly string[] {
+  if (!value) return [];
+  return value.split(',').map((entry) => entry.trim()).filter(Boolean);
+}
+
+function registryFromContext(ctx: CommandContext): AgentPersonaRegistry {
+  return AgentPersonaRegistry.fromShellPaths(requireShellPaths(ctx));
+}
+
+function summarizePersona(persona: AgentPersonaRecord, activePersonaId: string | null): string {
+  const active = persona.id === activePersonaId ? 'active' : 'inactive';
+  const tags = persona.tags.length > 0 ? ` tags=${persona.tags.join(',')}` : '';
+  return `  ${persona.id}  ${active}  ${persona.reviewState}  ${persona.name} - ${persona.description}${tags}`;
+}
+
+function renderList(title: string, registry: AgentPersonaRegistry, personas: readonly AgentPersonaRecord[]): string {
+  const snapshot = registry.snapshot();
+  if (personas.length === 0) {
+    return `${title}\n  No local Agent personas yet. Create one with /personas create --name <name> --description <summary> --body <instructions>.`;
+  }
+  return [
+    `${title} (${personas.length})`,
+    `  store: ${snapshot.path}`,
+    `  active: ${snapshot.activePersona?.name ?? '(none)'}`,
+    ...personas.map((persona) => summarizePersona(persona, snapshot.activePersonaId)),
+  ].join('\n');
+}
+
+function renderPersona(persona: AgentPersonaRecord, activePersonaId: string | null): string {
+  return [
+    `Persona ${persona.name}`,
+    `  id: ${persona.id}`,
+    `  active: ${persona.id === activePersonaId ? 'yes' : 'no'}`,
+    `  review: ${persona.reviewState}`,
+    `  source: ${persona.source}`,
+    `  provenance: ${persona.provenance}`,
+    `  tags: ${persona.tags.join(', ') || '(none)'}`,
+    `  triggers: ${persona.triggers.join(', ') || '(none)'}`,
+    `  created: ${persona.createdAt}`,
+    `  updated: ${persona.updatedAt}`,
+    persona.staleReason ? `  stale reason: ${persona.staleReason}` : '',
+    '',
+    persona.description,
+    '',
+    persona.body,
+  ].filter(Boolean).join('\n');
+}
+
+function requiredFlag(flags: ReadonlyMap<string, string>, key: string): string {
+  const value = flags.get(key)?.trim();
+  if (!value) throw new Error(`Missing --${key}.`);
+  return value;
+}
+
+function printError(ctx: CommandContext, error: unknown): void {
+  ctx.print(`Error: ${error instanceof Error ? error.message : String(error)}`);
+}
+
+export function registerPersonasRuntimeCommands(registry: CommandRegistry): void {
+  registry.register({
+    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]',
+    async handler(args, ctx) {
+      const sub = (args[0] ?? 'list').toLowerCase();
+      const registryStore = registryFromContext(ctx);
+      try {
+        if (sub === 'list' || sub === 'open') {
+          ctx.print(renderList('Agent Personas', registryStore, registryStore.list()));
+          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)));
+          return;
+        }
+        if (sub === 'show') {
+          const id = args[1];
+          if (!id) {
+            ctx.print('Usage: /personas show <id>');
+            return;
+          }
+          const snapshot = registryStore.snapshot();
+          const persona = registryStore.get(id);
+          ctx.print(persona ? renderPersona(persona, snapshot.activePersonaId) : `Unknown persona: ${id}`);
+          return;
+        }
+        if (sub === 'create') {
+          const parsed = parsePersonaArgs(args.slice(1));
+          const body = parsed.flags.get('body')?.trim() || parsed.rest.join(' ').trim();
+          const persona = registryStore.create({
+            name: requiredFlag(parsed.flags, 'name'),
+            description: requiredFlag(parsed.flags, 'description'),
+            body,
+            tags: splitList(parsed.flags.get('tags')),
+            triggers: splitList(parsed.flags.get('triggers')),
+            source: 'user',
+            provenance: 'slash-command',
+          });
+          ctx.print(`Created Agent persona ${persona.id}: ${persona.name}`);
+          return;
+        }
+        if (sub === 'update') {
+          const id = args[1];
+          if (!id) {
+            ctx.print('Usage: /personas update <id> [--name ...] [--description ...] [--body ...]');
+            return;
+          }
+          const parsed = parsePersonaArgs(args.slice(2));
+          const updated = registryStore.update(id, {
+            name: parsed.flags.get('name'),
+            description: parsed.flags.get('description'),
+            body: parsed.flags.get('body'),
+            tags: parsed.flags.has('tags') ? splitList(parsed.flags.get('tags')) : undefined,
+            triggers: parsed.flags.has('triggers') ? splitList(parsed.flags.get('triggers')) : undefined,
+            provenance: 'slash-command',
+          });
+          ctx.print(`Updated Agent persona ${updated.id}: ${updated.name}`);
+          return;
+        }
+        if (sub === 'use') {
+          const id = args[1];
+          if (!id) {
+            ctx.print('Usage: /personas use <id>');
+            return;
+          }
+          const persona = registryStore.setActive(id);
+          ctx.print(`Active Agent persona: ${persona.name} (${persona.id})`);
+          return;
+        }
+        if (sub === 'active') {
+          const snapshot = registryStore.snapshot();
+          ctx.print(snapshot.activePersona ? renderPersona(snapshot.activePersona, snapshot.activePersonaId) : 'No active Agent persona.');
+          return;
+        }
+        if (sub === 'clear') {
+          registryStore.clearActive();
+          ctx.print('Cleared active Agent persona.');
+          return;
+        }
+        if (sub === 'review') {
+          const id = args[1];
+          if (!id) {
+            ctx.print('Usage: /personas review <id>');
+            return;
+          }
+          const persona = registryStore.markReviewed(id);
+          ctx.print(`Reviewed Agent persona ${persona.id}.`);
+          return;
+        }
+        if (sub === 'stale') {
+          const id = args[1];
+          if (!id) {
+            ctx.print('Usage: /personas stale <id> <reason...>');
+            return;
+          }
+          const persona = registryStore.markStale(id, args.slice(2).join(' '));
+          ctx.print(`Marked Agent persona ${persona.id} stale.`);
+          return;
+        }
+        if (sub === 'delete' || sub === 'remove') {
+          const parsed = parsePersonaArgs(args.slice(1));
+          const id = parsed.rest[0];
+          if (!id) {
+            ctx.print('Usage: /personas delete <id> --yes');
+            return;
+          }
+          if (!parsed.yes) {
+            ctx.print(`Refusing to delete Agent persona ${id} without --yes.`);
+            return;
+          }
+          const removed = registryStore.deletePersona(id);
+          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]');
+      } catch (error) {
+        printError(ctx, error);
+      }
+    },
+  });
+}

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

@@ -12,15 +12,20 @@ import {
   upsertEcosystemCatalogEntry,
 } from '@/runtime/index.ts';
 import { requireEcosystemCatalogPaths, requirePanelManager, requireShellPaths } from './runtime-services.ts';
+import { runAgentSkillsRuntimeCommand } from './agent-skills-runtime.ts';
 
 export function registerSkillsRuntimeCommands(registry: CommandRegistry): void {
   registry.register({
     name: 'skills',
     aliases: ['skill'],
     description: 'Inspect installed skill packs',
-    usage: '[open|list|show <name>|origins|browse [query]|installed|catalog-review <id>|publish-local <id> <path> <summary...>|unpublish <id>|install-hint <catalog-id>|install <id> [project|user]|update <id> [project|user]|uninstall <id> [project|user]]',
+    usage: '[open|local ...|list|show <name>|origins|browse [query]|installed|catalog-review <id>|publish-local <id> <path> <summary...>|unpublish <id>|install-hint <catalog-id>|install <id> [project|user]|update <id> [project|user]|uninstall <id> [project|user]]',
     async handler(args, ctx) {
       const sub = args[0] ?? 'open';
+      if (sub === 'local' || sub === 'agent') {
+        await runAgentSkillsRuntimeCommand(args.slice(1), ctx);
+        return;
+      }
       if (sub === 'open' || sub === 'panel') {
         if (ctx.showPanel) ctx.showPanel('skills');
         else {
@@ -215,7 +220,7 @@ export function registerSkillsRuntimeCommands(registry: CommandRegistry): void {
         ctx.print(result.ok ? `Uninstalled curated skill ${entryId} from ${result.removedPath}` : `Error: ${result.error}`);
         return;
       }
-      ctx.print('Usage: /skills [open|list|show <name>|origins|browse [query]|installed|catalog-review <id>|publish-local <id> <path> <summary...>|unpublish <id>|install-hint <catalog-id>|install <id> [project|user]|update <id> [project|user]|uninstall <id> [project|user]]');
+      ctx.print('Usage: /skills [open|local ...|list|show <name>|origins|browse [query]|installed|catalog-review <id>|publish-local <id> <path> <summary...>|unpublish <id>|install-hint <catalog-id>|install <id> [project|user]|update <id> [project|user]|uninstall <id> [project|user]]');
     },
   });
 }

package/src/input/commands.ts

@@ -55,6 +55,8 @@ import { registerWorkPlanRuntimeCommands } from './commands/work-plan-runtime.ts
 import { registerAgentWorkspaceRuntimeCommands } from './commands/agent-workspace-runtime.ts';
 import { registerAgentExternalizedTuiCommands } from './commands/agent-externalized-tui.ts';
 import { registerDelegationRuntimeCommands } from './commands/delegation-runtime.ts';
+import { registerPersonasRuntimeCommands } from './commands/personas-runtime.ts';
+import { registerAgentSkillsRuntimeCommands } from './commands/agent-skills-runtime.ts';
 
 /**
  * registerBuiltinCommands - Register all built-in slash commands into the registry.
@@ -63,6 +65,8 @@ import { registerDelegationRuntimeCommands } from './commands/delegation-runtime
 export function registerBuiltinCommands(registry: CommandRegistry): void {
   registerShellCoreCommands(registry);
   registerAgentWorkspaceRuntimeCommands(registry);
+  registerPersonasRuntimeCommands(registry);
+  registerAgentSkillsRuntimeCommands(registry);
   registerDelegationRuntimeCommands(registry);
   registerConfigCommand(registry);
   registerOperatorRuntimeCommands(registry);

package/src/input/panel-integration-actions.ts

@@ -2,37 +2,8 @@ import type { CommandContext } from './command-registry.ts';
 import { logger } from '@pellux/goodvibes-sdk/platform/utils';
 import type { Panel } from '../panels/types.ts';
 import type { PanelManager } from '../panels/panel-manager.ts';
-import { FileExplorerPanel } from '../panels/file-explorer-panel.ts';
-import { FilePreviewPanel } from '../panels/file-preview-panel.ts';
-import { SymbolOutlinePanel } from '../panels/symbol-outline-panel.ts';
 import { ApprovalPanel } from '../panels/approval-panel.ts';
 
-function ensurePreviewPanel(panelManager: PanelManager): FilePreviewPanel | null {
-  const existing = panelManager.getPanel('preview');
-  if (existing instanceof FilePreviewPanel) {
-    const pane = panelManager.getPaneOf('preview');
-    panelManager.activateById('preview');
-    if (pane) panelManager.focusPane(pane);
-    return existing;
-  }
-  const targetPane: 'top' | 'bottom' = panelManager.isBottomPaneVisible()
-    ? (panelManager.getFocusedPane() === 'top' ? 'bottom' : 'top')
-    : 'bottom';
-  const opened = panelManager.open('preview', targetPane);
-  panelManager.show();
-  panelManager.focusPane(targetPane);
-  return opened instanceof FilePreviewPanel ? opened : null;
-}
-
-function syncSymbolOutlineFromPreview(panelManager: PanelManager, previewPanel: FilePreviewPanel): void {
-  const symbols = panelManager.getPanel('symbols');
-  const filePath = previewPanel.getCurrentFilePath();
-  const source = previewPanel.getSource();
-  if (symbols instanceof SymbolOutlinePanel && filePath && source !== null) {
-    symbols.loadFile(filePath, source);
-  }
-}
-
 export function handlePanelIntegrationAction(
   panelManager: PanelManager,
   activePanel: Panel | null,
@@ -41,29 +12,6 @@ export function handlePanelIntegrationAction(
 ): boolean {
   if (!activePanel) return false;
 
-  if ((key === 'enter' || key === 'return' || key === 'right') && activePanel instanceof FileExplorerPanel) {
-    const filePath = activePanel.getFocusedFilePath();
-    if (!filePath) return false;
-    const previewPanel = ensurePreviewPanel(panelManager);
-    if (!previewPanel) return false;
-    previewPanel.openFile(filePath);
-    syncSymbolOutlineFromPreview(panelManager, previewPanel);
-    return true;
-  }
-
-  if ((key === 'enter' || key === 'return') && activePanel instanceof SymbolOutlinePanel) {
-    const location = activePanel.getSelectedLocation();
-    if (!location) return false;
-    const previewPanel = ensurePreviewPanel(panelManager);
-    if (!previewPanel) return false;
-    if (previewPanel.getCurrentFilePath() !== location.path) {
-      previewPanel.openFile(location.path);
-      syncSymbolOutlineFromPreview(panelManager, previewPanel);
-    }
-    previewPanel.goToLine(location.line);
-    return true;
-  }
-
   if ((key === 'enter' || key === 'return') && activePanel instanceof ApprovalPanel) {
     const command = activePanel.getSelectedCommand();
     if (!command || !commandContext?.executeCommand) return false;

package/src/main.ts

@@ -54,6 +54,7 @@ import { allowTerminalWrite, installTuiTerminalOutputGuard } from './runtime/ter
 import { ProjectPlanningCoordinator } from './planning/project-planning-coordinator.ts';
 import { buildCommandArgsHint } from './input/command-args-hint.ts';
 import { summarizeRunningAgents } from './renderer/process-summary.ts';
+import { GOODVIBES_AGENT_PAIRING_SURFACE } from './config/surface.ts';
 
 const ALT_SCREEN_ENTER = '\x1b[?1049h';
 const ALT_SCREEN_EXIT  = '\x1b[?1049l';
@@ -320,7 +321,7 @@ async function main() {
               inputOptions = {
                 origin: {
                   source: 'project-planning',
-                  surface: 'tui',
+                  surface: GOODVIBES_AGENT_PAIRING_SURFACE,
                   metadata: {
                     projectId: ctx.services.projectPlanningProjectId,
                     knowledgeSpaceId: planning.state.knowledgeSpaceId,