@pellux/goodvibes-agent 0.1.80 → 0.1.82

package/src/cli/management.ts

@@ -1,4 +1,4 @@
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { existsSync, mkdirSync, writeFileSync } from 'node:fs';
 import { dirname, join } from 'node:path';
 import net from 'node:net';
 import { spawn } from 'node:child_process';
@@ -21,7 +21,6 @@ import { beginOpenAICodexLogin, exchangeOpenAICodexCode } from '@pellux/goodvibe
 import { inspectProviderAuth } from '@/runtime/index.ts';
 import { getOrCreateCompanionToken, buildCompanionConnectionInfo, encodeConnectionPayload, formatConnectionBlock } from '@pellux/goodvibes-sdk/platform/pairing';
 import { generateQrMatrix, renderQrToString } from '@pellux/goodvibes-sdk/platform/pairing';
-import { UserAuthManager } from '@pellux/goodvibes-sdk/platform/security';
 import type { GoodVibesCliParseResult } from './types.ts';
 import { formatProviderAuthRoute, summarizeProviderAuthRoutes } from './provider-auth-routes.ts';
 import { classifyProviderSetup } from './provider-classification.ts';
@@ -60,7 +59,7 @@ export function formatJsonOrText(cli: GoodVibesCliParseResult): Formatter {
 }
 
 function exitCodeForText(output: string): number {
-  if (output.startsWith('Usage:') || output.startsWith('Invalid ')) return 2;
+  if (output.startsWith('Usage:') || output.startsWith('Invalid ') || output.startsWith('Unsupported:')) return 2;
   if (output.startsWith('Session not found:') || output.startsWith('Unknown task:') || output.startsWith('Task submit failed ')) return 1;
   if (output.startsWith('No stored ') || output.startsWith('No pending ') || output.startsWith('No model ') || output.startsWith('No provider ') || output.startsWith('No auth ')) return 1;
   if (output.startsWith('Unknown ')) return 1;
@@ -74,59 +73,10 @@ function splitCommandOption(token: string): { readonly name: string; readonly va
   return { name: token.slice(0, index), value: token.slice(index + 1) };
 }
 
-function readOptionValue(args: readonly string[], name: string): string | undefined {
-  for (let index = 0; index < args.length; index += 1) {
-    const token = args[index]!;
-    const split = splitCommandOption(token);
-    if (split.name !== name) continue;
-    if (split.value !== undefined) return split.value;
-    const next = args[index + 1];
-    if (next === undefined || next.startsWith('--')) return undefined;
-    return next;
-  }
-  return undefined;
-}
-
-function readOptionValues(args: readonly string[], name: string): string[] {
-  const values: string[] = [];
-  for (let index = 0; index < args.length; index += 1) {
-    const token = args[index]!;
-    const split = splitCommandOption(token);
-    if (split.name !== name) continue;
-    if (split.value !== undefined) {
-      values.push(split.value);
-      continue;
-    }
-    const next = args[index + 1];
-    if (next !== undefined && !next.startsWith('--')) values.push(next);
-  }
-  return values;
-}
-
 export function hasCommandFlag(args: readonly string[], name: string): boolean {
   return args.some((arg) => splitCommandOption(arg).name === name);
 }
 
-function commandValues(args: readonly string[]): string[] {
-  const values: string[] = [];
-  for (let index = 0; index < args.length; index += 1) {
-    const token = args[index]!;
-    if (!token.startsWith('--')) {
-      values.push(token);
-      continue;
-    }
-    if (!token.includes('=') && args[index + 1] && !args[index + 1]!.startsWith('--')) index += 1;
-  }
-  return values;
-}
-
-function readPassword(args: readonly string[]): string | null {
-  const explicit = readOptionValue(args, '--password');
-  if (explicit !== undefined) return explicit;
-  if (hasCommandFlag(args, '--password-stdin')) return readFileSync(0, 'utf-8').trimEnd();
-  return process.env.GOODVIBES_AUTH_PASSWORD ?? null;
-}
-
 export function extractAuthorizationCode(input: string): string {
   try {
     const url = new URL(input);
@@ -291,14 +241,6 @@ export function readAuthPaths(runtime: CliCommandRuntime) {
   };
 }
 
-function createCliLocalUserAuthManager(runtime: CliCommandRuntime): UserAuthManager {
-  const paths = readAuthPaths(runtime);
-  return new UserAuthManager({
-    bootstrapFilePath: paths.userStorePath,
-    bootstrapCredentialPath: paths.bootstrapCredentialPath,
-  });
-}
-
 export async function runNonInteractiveAgent(runtime: CliCommandRuntime): Promise<number> {
   const prompt = runtime.cli.flags.prompt ?? runtime.cli.positionals.join(' ').trim();
   if (!prompt) {
@@ -584,84 +526,60 @@ async function renderModels(runtime: CliCommandRuntime): Promise<string> {
 }
 
 async function renderAuth(runtime: CliCommandRuntime): Promise<string> {
-  const localUserAuthManager = createCliLocalUserAuthManager(runtime);
-    const [sub = 'status', ...rawRest] = runtime.cli.commandArgs;
-    const rest = commandValues(rawRest);
-    if (sub === 'add-user' || sub === 'add') {
-      const username = rest[0];
-      if (!username) return 'Usage: goodvibes auth add-user <username> [--password <value>|--password-stdin] [--role <role>]';
-      const password = readPassword(rawRest);
-      if (!password) return 'Usage: goodvibes auth add-user <username> [--password <value>|--password-stdin] [--role <role>]';
-      const roles = readOptionValues(rawRest, '--role').filter((role) => role.length > 0);
-      const user = localUserAuthManager.addUser(username, password, roles.length > 0 ? roles : ['user']);
-      return `Auth user added: ${user.username} (${user.roles.join(', ') || 'no roles'})`;
-    }
-    if (sub === 'delete-user' || sub === 'remove-user') {
-      const username = rest[0];
-      if (!username) return 'Usage: goodvibes auth delete-user <username>';
-      return localUserAuthManager.deleteUser(username)
-        ? `Auth user deleted: ${username}`
-        : `No auth user found: ${username}`;
-    }
-    if (sub === 'rotate-password' || sub === 'passwd') {
-      const username = rest[0];
-      if (!username) return 'Usage: goodvibes auth rotate-password <username> [--password <value>|--password-stdin]';
-      const password = readPassword(rawRest);
-      if (!password) return 'Usage: goodvibes auth rotate-password <username> [--password <value>|--password-stdin]';
-      localUserAuthManager.rotatePassword(username, password);
-      return `Auth password rotated: ${username}`;
-    }
-    if (sub === 'revoke-session') {
-      const token = rest[0];
-      if (!token) return 'Usage: goodvibes auth revoke-session <token-or-fingerprint>';
-      return localUserAuthManager.revokeSession(token)
-        ? 'Auth session revoked.'
-        : 'No auth session found.';
-    }
-    if (sub === 'revoke-sessions') {
-      const username = rest[0];
-      if (!username) return 'Usage: goodvibes auth revoke-sessions <username>';
-      const count = localUserAuthManager.revokeSessionsForUser(username);
-      return `Auth sessions revoked for ${username}: ${count}`;
-    }
-    if (sub === 'clear-bootstrap') {
-      return localUserAuthManager.clearBootstrapCredentialFile()
-        ? 'Bootstrap credential file removed.'
-        : 'Bootstrap credential file was already absent.';
-    }
-    if (sub !== 'status' && sub !== 'list' && sub !== 'users' && sub !== 'sessions') {
-      return 'Usage: goodvibes auth [status|users|sessions|add-user|delete-user|rotate-password|revoke-session|revoke-sessions|clear-bootstrap]';
-    }
-    const snapshot = localUserAuthManager.inspect();
-    const paths = readAuthPaths(runtime);
-    const value = {
-      ...paths,
-      users: snapshot.users.map((user) => ({ username: user.username, roles: user.roles })),
-      sessions: snapshot.sessions.length,
-      permissionMode: runtime.configManager.get('permissions.mode'),
-    };
-    if (sub === 'users') {
-      return formatJsonOrText(runtime.cli)(value.users, [
-        `GoodVibes auth users (${value.users.length})`,
-        ...value.users.map((user) => `  ${user.username} (${user.roles.join(', ') || 'no roles'})`),
-      ].join('\n'));
-    }
-    if (sub === 'sessions') {
-      return formatJsonOrText(runtime.cli)(snapshot.sessions, [
-        `GoodVibes auth sessions (${snapshot.sessions.length})`,
-        ...snapshot.sessions.map((session) => `  ${session.username} expires=${new Date(session.expiresAt).toISOString()} fingerprint=${session.tokenFingerprint}`),
-      ].join('\n'));
-    }
+  const [sub = 'status'] = runtime.cli.commandArgs;
+  const blocked = new Set([
+    'add-user',
+    'add',
+    'delete-user',
+    'remove-user',
+    'rotate-password',
+    'passwd',
+    'revoke-session',
+    'revoke-sessions',
+    'clear-bootstrap',
+  ]);
+  if (blocked.has(sub)) {
+    return [
+      'Unsupported: runtime auth user/session administration is external to GoodVibes Agent.',
+      'GoodVibes Agent connects to an already-running runtime and does not create, delete, rotate, revoke, or clear runtime users, sessions, or bootstrap credentials.',
+      'Use the runtime-owning GoodVibes TUI or host tooling for runtime auth administration.',
+    ].join('\n');
+  }
+  if (sub !== 'status' && sub !== 'review' && sub !== 'list' && sub !== 'users' && sub !== 'sessions') {
+    return 'Usage: goodvibes-agent auth [status|review|users|sessions]';
+  }
+  const paths = readAuthPaths(runtime);
+  const value = {
+    authOwner: 'external-runtime',
+    operatorTokenPresent: paths.operatorTokenPresent,
+    operatorTokenPath: paths.operatorTokenPath,
+    compatibilityUserStorePresent: paths.userStorePresent,
+    compatibilityUserStorePath: paths.userStorePath,
+    compatibilityBootstrapCredentialPresent: paths.bootstrapCredentialPresent,
+    compatibilityBootstrapCredentialPath: paths.bootstrapCredentialPath,
+    permissionMode: runtime.configManager.get('permissions.mode'),
+  };
+  if (sub === 'users' || sub === 'sessions') {
     return formatJsonOrText(runtime.cli)(value, [
-      'GoodVibes auth',
-      `  permission mode: ${String(value.permissionMode)}`,
-      `  users: ${value.users.length}`,
-      ...value.users.map((user) => `    ${user.username} (${user.roles.join(', ') || 'no roles'})`),
-      `  sessions: ${value.sessions}`,
-      `  user store: ${paths.userStorePresent ? 'present' : 'missing'} (${paths.userStorePath})`,
-      `  bootstrap credential: ${paths.bootstrapCredentialPresent ? 'present' : 'missing'} (${paths.bootstrapCredentialPath})`,
-      `  operator tokens: ${paths.operatorTokenPresent ? 'present' : 'missing'} (${paths.operatorTokenPath})`,
+      `GoodVibes Agent auth ${sub}`,
+      '  owner: external GoodVibes runtime',
+      `  operator token: ${paths.operatorTokenPresent ? 'present' : 'missing'}`,
+      `  operator token path: ${paths.operatorTokenPath}`,
+      `  ${sub}: managed by the runtime-owning TUI or host tooling`,
+      '  Agent does not enumerate or mutate runtime users/sessions from the local CLI.',
     ].join('\n'));
+  }
+  return formatJsonOrText(runtime.cli)(value, [
+    'GoodVibes Agent auth',
+    '  owner: external GoodVibes runtime',
+    `  permission mode: ${String(value.permissionMode)}`,
+    `  operator token: ${paths.operatorTokenPresent ? 'present' : 'missing'} (${paths.operatorTokenPath})`,
+    `  compatibility user store: ${paths.userStorePresent ? 'present' : 'missing'} (${paths.userStorePath})`,
+    `  compatibility bootstrap credential: ${paths.bootstrapCredentialPresent ? 'present' : 'missing'} (${paths.bootstrapCredentialPath})`,
+    '  runtime user/session administration: external',
+    '  next: goodvibes-agent providers',
+    '  next: goodvibes-agent subscription providers',
+  ].join('\n'));
 }
 
 

package/src/cli/status.ts

@@ -50,7 +50,7 @@ export interface CliStatusSnapshot {
     readonly permissionLabel: string;
     readonly secretPolicy: unknown;
     readonly secretPolicyLabel: string;
-    readonly localUsers: CliAuthStatus | null;
+    readonly runtimeAuthSignal: CliAuthStatus | null;
   };
   readonly runtimeConnection: {
     readonly enabled: unknown;
@@ -182,13 +182,13 @@ export function buildCliDoctorFindings(options: CliStatusOptions): readonly CliD
 
   if (networkFacingSurfaces.length > 0 && options.auth?.userStorePresent !== true) {
     findings.push({
-      id: 'network-endpoint-without-local-users',
+      id: 'network-endpoint-without-runtime-auth-signal',
       area: 'auth',
       severity: 'risk',
-      summary: 'Network-facing runtime endpoints are enabled before local users are configured.',
-      cause: `${networkFacingSurfaces.map(([name]) => name).join(', ')} are LAN/custom-bound, but no local auth user store was found.`,
-      impact: 'Remote access paths may be unusable or unsafe until local admin auth is configured.',
-      action: 'Create/verify a local admin user before exposing GoodVibes on the network.',
+      summary: 'Network-facing runtime endpoints are enabled without a visible runtime auth signal.',
+      cause: `${networkFacingSurfaces.map(([name]) => name).join(', ')} are LAN/custom-bound, but Agent cannot see runtime auth state from its local compatibility files.`,
+      impact: 'Remote access paths may be unusable or unsafe unless the external runtime owner configured auth.',
+      action: 'Review runtime auth from the owning GoodVibes TUI or host tooling; Agent will not create local runtime users.',
     });
   }
 
@@ -200,7 +200,7 @@ export function buildCliDoctorFindings(options: CliStatusOptions): readonly CliD
       summary: 'A bootstrap credential is still present while network-facing surfaces are enabled.',
       cause: `${networkFacingSurfaces.map(([name]) => name).join(', ')} are LAN/custom-bound and auth-bootstrap.txt exists.`,
       impact: 'Bootstrap credentials should be treated as temporary setup material, not long-lived network access credentials.',
-      action: 'Replace bootstrap auth with a named admin user and retire the bootstrap credential.',
+      action: 'Use the runtime-owning GoodVibes TUI or host tooling to replace bootstrap auth and retire the bootstrap credential.',
     });
   }
 
@@ -264,7 +264,7 @@ export function buildCliStatusSnapshot(options: CliStatusOptions): CliStatusSnap
       permissionLabel: permissionModeLabel(config.get('permissions.mode')),
       secretPolicy: config.get('storage.secretPolicy'),
       secretPolicyLabel: secretPolicyLabel(config.get('storage.secretPolicy')),
-      localUsers: options.auth ?? null,
+      runtimeAuthSignal: options.auth ?? null,
     },
     runtimeConnection: {
       enabled: config.get('service.enabled'),
@@ -317,8 +317,8 @@ export function renderCliStatus(options: CliStatusOptions): string {
     `  permissions: ${permissionModeLabel(config.get('permissions.mode'))} (${String(config.get('permissions.mode'))})`,
     `  secretPolicy: ${secretPolicyLabel(config.get('storage.secretPolicy'))} (${String(config.get('storage.secretPolicy'))})`,
     options.auth
-      ? `  localUsers: ${options.auth.userStorePresent ? 'present' : 'missing'} (${options.auth.userStorePath})`
-      : '  localUsers: unknown',
+      ? `  runtimeAuthSignal: ${options.auth.userStorePresent ? 'present' : 'missing'} (${options.auth.userStorePath})`
+      : '  runtimeAuthSignal: unknown',
     options.auth
       ? `  bootstrapCredential: ${options.auth.bootstrapCredentialPresent ? 'present' : 'missing'} (${options.auth.bootstrapCredentialPath})`
       : '  bootstrapCredential: unknown',

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

@@ -144,6 +144,8 @@ export const AGENT_WORKSPACE_CATEGORIES: readonly AgentWorkspaceCategory[] = [
     actions: [
       { id: 'skills-list', label: 'List skills', detail: 'Print the full local Agent skill library.', command: '/agent-skills list', kind: 'command', safety: 'read-only' },
       { id: 'skills-enabled', label: 'Enabled skills', detail: 'Show only skills currently injected into Agent guidance.', command: '/agent-skills enabled', kind: 'command', safety: 'read-only' },
+      { id: 'skills-bundles', label: 'Skill bundles', detail: 'List reviewable groups of local skills that can be enabled together.', command: '/agent-skills bundle list', kind: 'command', safety: 'read-only' },
+      { id: 'skills-create-bundle', label: 'Create bundle', detail: 'Create a named skill bundle from existing skill ids with an explicit command.', command: '/agent-skills bundle create --name <name> --description <summary> --skills <id,id>', kind: 'command', safety: 'safe' },
       { id: 'skills-prev', label: 'Previous skill', detail: 'Move the local skill selection up without changing enabled state.', localKind: 'skill', selectionDelta: -1, kind: 'local-selection', safety: 'safe' },
       { id: 'skills-next', label: 'Next skill', detail: 'Move the local skill selection down without changing enabled state.', localKind: 'skill', selectionDelta: 1, kind: 'local-selection', safety: 'safe' },
       { id: 'skills-create', label: 'Create skill', detail: 'Open an in-workspace form for a reusable local procedure. No placeholder command is dispatched.', editorKind: 'skill', kind: 'editor', safety: 'safe' },

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

@@ -17,6 +17,8 @@ export interface AgentWorkspaceSetupChecklistInput {
   readonly enabledRoutineCount: number;
   readonly skillCount: number;
   readonly enabledSkillCount: number;
+  readonly skillBundleCount: number;
+  readonly enabledSkillBundleCount: number;
   readonly activePersonaName: string;
   readonly readyChannelCount: number;
   readonly voiceProviderCount: number;
@@ -77,10 +79,10 @@ export function buildAgentWorkspaceSetupChecklist(input: AgentWorkspaceSetupChec
     {
       id: 'skills',
       label: 'Skills',
-      status: setupStatusForCount(input.enabledSkillCount, 'ready', input.skillCount > 0 ? 'recommended' : 'optional'),
-      detail: input.skillCount > 0
-        ? `${input.enabledSkillCount}/${input.skillCount} local skill(s) enabled.`
-        : 'Create reusable local skills for repeated workflows.',
+      status: input.enabledSkillCount > 0 || input.enabledSkillBundleCount > 0 ? 'ready' : input.skillCount > 0 || input.skillBundleCount > 0 ? 'recommended' : 'optional',
+      detail: input.skillCount > 0 || input.skillBundleCount > 0
+        ? `${input.enabledSkillCount}/${input.skillCount} local skill(s) enabled; ${input.enabledSkillBundleCount}/${input.skillBundleCount} bundle(s) enabled.`
+        : 'Create reusable local skills and bundles for repeated workflows.',
       command: '/agent-skills',
     },
     {

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

@@ -2,7 +2,7 @@ import { basename, sep } from 'node:path';
 import type { CommandContext } from './command-registry.ts';
 import { AgentPersonaRegistry, type AgentPersonaRecord } from '../agent/persona-registry.ts';
 import { AgentRoutineRegistry, type AgentRoutineRecord } from '../agent/routine-registry.ts';
-import { AgentSkillRegistry, type AgentSkillRecord } from '../agent/skill-registry.ts';
+import { AgentSkillRegistry, type AgentSkillBundleRecord, type AgentSkillRecord } from '../agent/skill-registry.ts';
 import { getAgentRuntimeProfilesRoot, listAgentRuntimeProfiles, listAgentRuntimeProfileTemplates } from '../agent/runtime-profile.ts';
 import { buildAgentWorkspaceChannels } from './agent-workspace-channels.ts';
 import { buildAgentWorkspaceSetupChecklist } from './agent-workspace-setup.ts';
@@ -86,6 +86,19 @@ function summarizeSkillItem(skill: AgentSkillRecord): AgentWorkspaceLocalLibrary
   };
 }
 
+function summarizeSkillBundleItem(bundle: AgentSkillBundleRecord): AgentWorkspaceLocalLibraryItem {
+  return {
+    id: bundle.id,
+    name: bundle.name,
+    description: `${bundle.description} Skills: ${bundle.skillIds.join(', ')}`,
+    reviewState: bundle.reviewState,
+    source: bundle.source,
+    tags: bundle.skillIds,
+    triggers: [],
+    enabled: bundle.enabled,
+  };
+}
+
 function summarizeRoutineItem(routine: AgentRoutineRecord): AgentWorkspaceLocalLibraryItem {
   return {
     id: routine.id,
@@ -158,15 +171,19 @@ export function buildAgentWorkspaceRuntimeSnapshot(context: CommandContext): Age
   const skillSnapshot = (() => {
     try {
       const shellPaths = context.workspace?.shellPaths;
-      if (!shellPaths) return { count: 0, enabled: 0, items: [] };
+      if (!shellPaths) return { count: 0, enabled: 0, active: 0, bundleCount: 0, enabledBundleCount: 0, items: [], bundleItems: [] };
       const snapshot = AgentSkillRegistry.fromShellPaths(shellPaths).snapshot();
       return {
         count: snapshot.skills.length,
         enabled: snapshot.enabledSkills.length,
+        active: snapshot.activeSkills.length,
+        bundleCount: snapshot.bundles.length,
+        enabledBundleCount: snapshot.enabledBundles.length,
         items: snapshot.skills.map(summarizeSkillItem),
+        bundleItems: snapshot.bundles.map(summarizeSkillBundleItem),
       };
     } catch {
-      return { count: 0, enabled: 0, items: [] };
+      return { count: 0, enabled: 0, active: 0, bundleCount: 0, enabledBundleCount: 0, items: [], bundleItems: [] };
     }
   })();
   const routineSnapshot = (() => {
@@ -251,6 +268,8 @@ export function buildAgentWorkspaceRuntimeSnapshot(context: CommandContext): Age
     enabledRoutineCount: routineSnapshot.enabled,
     skillCount: skillSnapshot.count,
     enabledSkillCount: skillSnapshot.enabled,
+    skillBundleCount: skillSnapshot.bundleCount,
+    enabledSkillBundleCount: skillSnapshot.enabledBundleCount,
     activePersonaName: personaSnapshot.activeName,
     readyChannelCount: channels.filter((channel) => channel.ready).length,
     voiceProviderCount: voiceProviders.length,
@@ -274,6 +293,10 @@ export function buildAgentWorkspaceRuntimeSnapshot(context: CommandContext): Age
     localRoutines: routineSnapshot.items,
     localSkillCount: skillSnapshot.count,
     enabledSkillCount: skillSnapshot.enabled,
+    localSkillBundleCount: skillSnapshot.bundleCount,
+    enabledSkillBundleCount: skillSnapshot.enabledBundleCount,
+    activeSkillCount: skillSnapshot.active,
+    localSkillBundles: skillSnapshot.bundleItems,
     localSkills: skillSnapshot.items,
     localPersonaCount: personaSnapshot.count,
     activePersonaName: personaSnapshot.activeName,

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

@@ -128,6 +128,10 @@ export interface AgentWorkspaceRuntimeSnapshot {
   readonly localRoutines: readonly AgentWorkspaceLocalLibraryItem[];
   readonly localSkillCount: number;
   readonly enabledSkillCount: number;
+  readonly localSkillBundleCount: number;
+  readonly enabledSkillBundleCount: number;
+  readonly activeSkillCount: number;
+  readonly localSkillBundles: readonly AgentWorkspaceLocalLibraryItem[];
   readonly localSkills: readonly AgentWorkspaceLocalLibraryItem[];
   readonly localPersonaCount: number;
   readonly activePersonaName: string;

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

@@ -1,4 +1,4 @@
-import { AgentSkillRegistry, type AgentSkillRecord } from '../../agent/skill-registry.ts';
+import { AgentSkillRegistry, type AgentSkillBundleRecord, type AgentSkillRecord } from '../../agent/skill-registry.ts';
 import type { CommandContext, CommandRegistry } from '../command-registry.ts';
 import { requireShellPaths } from './runtime-services.ts';
 
@@ -55,6 +55,11 @@ function summarizeSkill(skill: AgentSkillRecord): string {
   return `  ${skill.id}  ${enabled}  ${skill.reviewState}  ${skill.name} - ${skill.description}${tags}`;
 }
 
+function summarizeBundle(bundle: AgentSkillBundleRecord): string {
+  const enabled = bundle.enabled ? 'enabled' : 'disabled';
+  return `  ${bundle.id}  ${enabled}  ${bundle.reviewState}  ${bundle.name} - ${bundle.description}  skills=${bundle.skillIds.join(',')}`;
+}
+
 function renderList(title: string, registry: AgentSkillRegistry, skills: readonly AgentSkillRecord[]): string {
   const snapshot = registry.snapshot();
   if (skills.length === 0) {
@@ -68,6 +73,20 @@ function renderList(title: string, registry: AgentSkillRegistry, skills: readonl
   ].join('\n');
 }
 
+function renderBundleList(title: string, registry: AgentSkillRegistry, bundles: readonly AgentSkillBundleRecord[]): string {
+  const snapshot = registry.snapshot();
+  if (bundles.length === 0) {
+    return `${title}\n  No local Agent skill bundles yet. Create one with /agent-skills bundle create --name <name> --description <summary> --skills <id,id>.`;
+  }
+  return [
+    `${title} (${bundles.length})`,
+    `  store: ${snapshot.path}`,
+    `  enabled bundles: ${snapshot.enabledBundles.length}`,
+    `  active skills: ${snapshot.activeSkills.length}`,
+    ...bundles.map(summarizeBundle),
+  ].join('\n');
+}
+
 function renderSkill(skill: AgentSkillRecord): string {
   return [
     `Skill ${skill.name}`,
@@ -88,14 +107,143 @@ function renderSkill(skill: AgentSkillRecord): string {
   ].filter(Boolean).join('\n');
 }
 
+function renderBundle(bundle: AgentSkillBundleRecord, registry: AgentSkillRegistry): string {
+  const skills = bundle.skillIds
+    .map((skillId) => registry.get(skillId))
+    .filter((skill): skill is AgentSkillRecord => skill !== null);
+  return [
+    `Skill Bundle ${bundle.name}`,
+    `  id: ${bundle.id}`,
+    `  enabled: ${bundle.enabled ? 'yes' : 'no'}`,
+    `  review: ${bundle.reviewState}`,
+    `  source: ${bundle.source}`,
+    `  provenance: ${bundle.provenance}`,
+    `  skills: ${bundle.skillIds.join(', ')}`,
+    `  created: ${bundle.createdAt}`,
+    `  updated: ${bundle.updatedAt}`,
+    bundle.staleReason ? `  stale reason: ${bundle.staleReason}` : '',
+    '',
+    bundle.description,
+    '',
+    ...skills.map((skill) => `- ${skill.id}: ${skill.name} - ${skill.description}`),
+  ].filter(Boolean).join('\n');
+}
+
 function printError(ctx: CommandContext, error: unknown): void {
   ctx.print(`Error: ${error instanceof Error ? error.message : String(error)}`);
 }
 
+function runBundleCommand(args: readonly string[], ctx: CommandContext, skillRegistry: AgentSkillRegistry): void {
+  const sub = (args[0] ?? 'list').toLowerCase();
+  if (sub === 'list' || sub === 'open') {
+    ctx.print(renderBundleList('Agent Skill Bundles', skillRegistry, skillRegistry.listBundles()));
+    return;
+  }
+  if (sub === 'enabled') {
+    const snapshot = skillRegistry.snapshot();
+    ctx.print(renderBundleList('Enabled Agent Skill Bundles', skillRegistry, snapshot.enabledBundles));
+    return;
+  }
+  if (sub === 'search') {
+    const query = args.slice(1).join(' ').trim();
+    ctx.print(renderBundleList(query ? `Agent Skill Bundles matching "${query}"` : 'Agent Skill Bundles', skillRegistry, skillRegistry.searchBundles(query)));
+    return;
+  }
+  if (sub === 'show') {
+    const id = args[1];
+    if (!id) {
+      ctx.print('Usage: /agent-skills bundle show <id>');
+      return;
+    }
+    const bundle = skillRegistry.getBundle(id);
+    ctx.print(bundle ? renderBundle(bundle, skillRegistry) : `Unknown Agent skill bundle: ${id}`);
+    return;
+  }
+  if (sub === 'create') {
+    const parsed = parseSkillArgs(args.slice(1));
+    const bundle = skillRegistry.createBundle({
+      name: requiredFlag(parsed.flags, 'name'),
+      description: requiredFlag(parsed.flags, 'description'),
+      skillIds: splitList(requiredFlag(parsed.flags, 'skills')),
+      enabled: parsed.flags.get('enabled') === 'true',
+      source: 'user',
+      provenance: 'slash-command',
+    });
+    ctx.print(`Created Agent skill bundle ${bundle.id}: ${bundle.name}`);
+    return;
+  }
+  if (sub === 'update') {
+    const id = args[1];
+    if (!id) {
+      ctx.print('Usage: /agent-skills bundle update <id> [--name ...] [--description ...] [--skills id,id]');
+      return;
+    }
+    const parsed = parseSkillArgs(args.slice(2));
+    const updated = skillRegistry.updateBundle(id, {
+      name: parsed.flags.get('name'),
+      description: parsed.flags.get('description'),
+      skillIds: parsed.flags.has('skills') ? splitList(parsed.flags.get('skills')) : undefined,
+      provenance: 'slash-command',
+    });
+    ctx.print(`Updated Agent skill bundle ${updated.id}: ${updated.name}`);
+    return;
+  }
+  if (sub === 'enable' || sub === 'disable') {
+    const id = args[1];
+    if (!id) {
+      ctx.print(`Usage: /agent-skills bundle ${sub} <id>`);
+      return;
+    }
+    const bundle = skillRegistry.setBundleEnabled(id, sub === 'enable');
+    ctx.print(`${sub === 'enable' ? 'Enabled' : 'Disabled'} Agent skill bundle ${bundle.id}: ${bundle.name}`);
+    return;
+  }
+  if (sub === 'review') {
+    const id = args[1];
+    if (!id) {
+      ctx.print('Usage: /agent-skills bundle review <id>');
+      return;
+    }
+    const bundle = skillRegistry.markBundleReviewed(id);
+    ctx.print(`Reviewed Agent skill bundle ${bundle.id}.`);
+    return;
+  }
+  if (sub === 'stale') {
+    const id = args[1];
+    if (!id) {
+      ctx.print('Usage: /agent-skills bundle stale <id> <reason...>');
+      return;
+    }
+    const bundle = skillRegistry.markBundleStale(id, args.slice(2).join(' '));
+    ctx.print(`Marked Agent skill bundle ${bundle.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 bundle delete <id> --yes');
+      return;
+    }
+    if (!parsed.yes) {
+      ctx.print(`Refusing to delete Agent skill bundle ${id} without --yes.`);
+      return;
+    }
+    const removed = skillRegistry.deleteBundle(id);
+    ctx.print(`Deleted Agent skill bundle ${removed.id}: ${removed.name}`);
+    return;
+  }
+  ctx.print('Usage: /agent-skills bundle [list|enabled|search|show|create|update|enable|disable|review|stale|delete]');
+}
+
 export async function runAgentSkillsRuntimeCommand(args: readonly string[], ctx: CommandContext): Promise<void> {
   const sub = (args[0] ?? 'list').toLowerCase();
   const skillRegistry = registryFromContext(ctx);
   try {
+    if (sub === 'bundle' || sub === 'bundles') {
+      runBundleCommand(args.slice(1), ctx, skillRegistry);
+      return;
+    }
     if (sub === 'list' || sub === 'open') {
       ctx.print(renderList('Agent Skills', skillRegistry, skillRegistry.list()));
       return;
@@ -199,7 +347,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]');
+    ctx.print('Usage: /agent-skills [list|enabled|search|show|create|update|enable|disable|review|stale|delete|bundle]');
   } catch (error) {
     printError(ctx, error);
   }
@@ -210,7 +358,7 @@ export function registerAgentSkillsRuntimeCommands(registry: CommandRegistry): v
     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]',
+    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 ...]',
     handler: runAgentSkillsRuntimeCommand,
   });
 }