@pellux/goodvibes-agent 0.1.79 → 0.1.81

package/CHANGELOG.md

@@ -2,6 +2,18 @@
 
 All notable changes to GoodVibes Agent will be recorded here.
 
+## 0.1.81 - 2026-06-01
+
+- Added local Agent skill bundles so users can group related local skills, enable or disable the bundle, and inject the bundle's member procedures into the same serial assistant conversation.
+- Added `/agent-skills bundle ...` commands plus Agent workspace visibility for skill bundle counts, enabled bundle state, active skill count, and bundle membership.
+- Restored the GitHub CI eval gate script and replaced the copied TUI/daemon release workflow with an Agent package release workflow that validates Bun global install, package contents, compiled binary launch, and optional npm publish.
+- Kept bundles Agent-local and reviewable with no daemon lifecycle behavior, hidden background agents, or non-Agent knowledge fallback.
+
+## 0.1.80 - 2026-06-01
+
+- Added an Agent day-one readiness checklist to the onboarding review step covering runtime connection, default model route, profile setup, isolated Agent Knowledge, local behavior, channels, routines/schedules, and explicit build delegation.
+- Kept the first-run review focused on Agent setup outcomes instead of copied runtime lifecycle or non-Agent knowledge behavior.
+
 ## 0.1.79 - 2026-06-01
 
 - Expanded the Voice & Media workspace into a provider readiness matrix covering selected TTS readiness, missing secret key names, media understanding/generation posture, and browser-tool state.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pellux/goodvibes-agent",
-  "version": "0.1.79",
+  "version": "0.1.81",
   "private": false,
   "description": "GoodVibes personal operator assistant TUI with a proactive Agent product brain, isolated Agent Knowledge, local profiles, routines, skills, personas, and explicit build delegation.",
   "type": "module",
@@ -92,6 +92,8 @@
     "publish:dry-run": "bun run scripts/publish-package.ts --dry-run",
     "publish:check": "bun run scripts/publish-check.ts",
     "package:install-check": "bun run scripts/package-install-check.ts",
+    "eval:gate": "bun test src/test/runtime/eval/runner.test.ts",
+    "ci:gate": "bun run typecheck && bun run test && bun run architecture:check && bun run perf:check && bun run eval:gate && bun run build && bun run publish:check && bun run package:install-check && bun run verification:ledger",
     "build:prod": "bun run scripts/build.ts",
     "build:all": "bun run scripts/build.ts --all",
     "perf:check": "bun run scripts/perf-check.ts",

package/src/agent/skill-registry.ts

@@ -24,6 +24,21 @@ export interface AgentSkillRecord {
   readonly reviewedAt?: string;
 }
 
+export interface AgentSkillBundleRecord {
+  readonly id: string;
+  readonly name: string;
+  readonly description: string;
+  readonly skillIds: readonly string[];
+  readonly enabled: boolean;
+  readonly source: AgentSkillSource;
+  readonly provenance: string;
+  readonly reviewState: AgentSkillReviewState;
+  readonly staleReason?: string;
+  readonly createdAt: string;
+  readonly updatedAt: string;
+  readonly reviewedAt?: string;
+}
+
 export interface AgentSkillCreateInput {
   readonly name: string;
   readonly description: string;
@@ -35,6 +50,15 @@ export interface AgentSkillCreateInput {
   readonly provenance?: string;
 }
 
+export interface AgentSkillBundleCreateInput {
+  readonly name: string;
+  readonly description: string;
+  readonly skillIds: readonly string[];
+  readonly enabled?: boolean;
+  readonly source?: AgentSkillSource;
+  readonly provenance?: string;
+}
+
 export interface AgentSkillUpdateInput {
   readonly name?: string;
   readonly description?: string;
@@ -44,15 +68,26 @@ export interface AgentSkillUpdateInput {
   readonly provenance?: string;
 }
 
+export interface AgentSkillBundleUpdateInput {
+  readonly name?: string;
+  readonly description?: string;
+  readonly skillIds?: readonly string[];
+  readonly provenance?: string;
+}
+
 export interface AgentSkillSnapshot {
   readonly path: string;
   readonly skills: readonly AgentSkillRecord[];
   readonly enabledSkills: readonly AgentSkillRecord[];
+  readonly bundles: readonly AgentSkillBundleRecord[];
+  readonly enabledBundles: readonly AgentSkillBundleRecord[];
+  readonly activeSkills: readonly AgentSkillRecord[];
 }
 
 interface SkillStoreFile {
   readonly version: 1;
   readonly skills: readonly AgentSkillRecord[];
+  readonly bundles: readonly AgentSkillBundleRecord[];
 }
 
 const STORE_VERSION = 1;
@@ -126,14 +161,44 @@ function parseSkill(value: unknown): AgentSkillRecord | null {
   };
 }
 
+function parseBundle(value: unknown): AgentSkillBundleRecord | null {
+  if (!isRecord(value)) return null;
+  const id = readString(value.id).trim();
+  const name = normalizeName(readString(value.name));
+  const description = readString(value.description).trim();
+  const skillIds = readStringArray(value.skillIds).map(slugify).filter(Boolean);
+  if (!id || !name || !description || skillIds.length === 0) return null;
+  const reviewState = value.reviewState === 'reviewed' || value.reviewState === 'stale' ? value.reviewState : 'fresh';
+  const source = value.source === 'agent' || value.source === 'imported' || value.source === 'system' ? value.source : 'user';
+  const staleReason = readString(value.staleReason).trim();
+  const reviewedAt = readString(value.reviewedAt).trim();
+  return {
+    id,
+    name,
+    description,
+    skillIds: normalizeList(skillIds).map(slugify),
+    enabled: value.enabled === true,
+    source,
+    provenance: readString(value.provenance, source).trim() || source,
+    reviewState,
+    staleReason: staleReason || undefined,
+    createdAt: readString(value.createdAt, nowIso()),
+    updatedAt: readString(value.updatedAt, nowIso()),
+    reviewedAt: reviewedAt || undefined,
+  };
+}
+
 function parseStore(raw: string): SkillStoreFile {
   const parsed: unknown = JSON.parse(raw);
-  if (!isRecord(parsed)) return { version: STORE_VERSION, skills: [] };
+  if (!isRecord(parsed)) return { version: STORE_VERSION, skills: [], bundles: [] };
   return {
     version: STORE_VERSION,
     skills: Array.isArray(parsed.skills)
       ? parsed.skills.map(parseSkill).filter((entry): entry is AgentSkillRecord => entry !== null)
       : [],
+    bundles: Array.isArray(parsed.bundles)
+      ? parsed.bundles.map(parseBundle).filter((entry): entry is AgentSkillBundleRecord => entry !== null)
+      : [],
   };
 }
 
@@ -154,10 +219,18 @@ export class AgentSkillRegistry {
 
   public snapshot(): AgentSkillSnapshot {
     const store = this.readStore();
+    const enabledBundles = store.bundles.filter((bundle) => bundle.enabled);
+    const activeSkillIds = new Set<string>(store.skills.filter((skill) => skill.enabled).map((skill) => skill.id));
+    for (const bundle of enabledBundles) {
+      for (const skillId of bundle.skillIds) activeSkillIds.add(skillId);
+    }
     return {
       path: this.storePath,
       skills: [...store.skills],
       enabledSkills: store.skills.filter((skill) => skill.enabled),
+      bundles: [...store.bundles],
+      enabledBundles,
+      activeSkills: store.skills.filter((skill) => activeSkillIds.has(skill.id)),
     };
   }
 
@@ -178,12 +251,33 @@ export class AgentSkillRegistry {
     ].some((field) => field.toLowerCase().includes(normalized)));
   }
 
+  public listBundles(): readonly AgentSkillBundleRecord[] {
+    return this.snapshot().bundles;
+  }
+
+  public searchBundles(query: string): readonly AgentSkillBundleRecord[] {
+    const normalized = query.trim().toLowerCase();
+    if (!normalized) return this.listBundles();
+    return this.listBundles().filter((bundle) => [
+      bundle.id,
+      bundle.name,
+      bundle.description,
+      ...bundle.skillIds,
+    ].some((field) => field.toLowerCase().includes(normalized)));
+  }
+
   public get(idOrName: string): AgentSkillRecord | null {
     const lookup = idOrName.trim().toLowerCase();
     if (!lookup) return null;
     return this.list().find((skill) => skill.id.toLowerCase() === lookup || skill.name.toLowerCase() === lookup) ?? null;
   }
 
+  public getBundle(idOrName: string): AgentSkillBundleRecord | null {
+    const lookup = idOrName.trim().toLowerCase();
+    if (!lookup) return null;
+    return this.listBundles().find((bundle) => bundle.id.toLowerCase() === lookup || bundle.name.toLowerCase() === lookup) ?? null;
+  }
+
   public create(input: AgentSkillCreateInput): AgentSkillRecord {
     const store = this.readStore();
     const name = normalizeName(input.name);
@@ -212,6 +306,32 @@ export class AgentSkillRegistry {
     return skill;
   }
 
+  public createBundle(input: AgentSkillBundleCreateInput): AgentSkillBundleRecord {
+    const store = this.readStore();
+    const name = normalizeName(input.name);
+    const description = input.description.trim();
+    const skillIds = this.normalizeExistingSkillIds(store, input.skillIds);
+    this.validateBundleRequired(name, description, skillIds);
+    assertNoSecretLikeText([name, description, ...skillIds]);
+    const duplicate = store.bundles.find((bundle) => bundle.name.toLowerCase() === name.toLowerCase());
+    if (duplicate) throw new Error(`Skill bundle already exists: ${duplicate.id}`);
+    const timestamp = nowIso();
+    const bundle: AgentSkillBundleRecord = {
+      id: this.nextBundleId(name, store.bundles),
+      name,
+      description,
+      skillIds,
+      enabled: input.enabled === true,
+      source: input.source ?? 'user',
+      provenance: input.provenance?.trim() || input.source || 'user',
+      reviewState: 'fresh',
+      createdAt: timestamp,
+      updatedAt: timestamp,
+    };
+    this.writeStore({ ...store, bundles: [...store.bundles, bundle] });
+    return bundle;
+  }
+
   public update(idOrName: string, input: AgentSkillUpdateInput): AgentSkillRecord {
     const store = this.readStore();
     const existing = this.findInStore(store, idOrName);
@@ -243,6 +363,35 @@ export class AgentSkillRegistry {
     return updated;
   }
 
+  public updateBundle(idOrName: string, input: AgentSkillBundleUpdateInput): AgentSkillBundleRecord {
+    const store = this.readStore();
+    const existing = this.findBundleInStore(store, idOrName);
+    if (!existing) throw new Error(`Unknown skill bundle: ${idOrName}`);
+    const name = input.name === undefined ? existing.name : normalizeName(input.name);
+    const description = input.description === undefined ? existing.description : input.description.trim();
+    const skillIds = input.skillIds === undefined ? existing.skillIds : this.normalizeExistingSkillIds(store, input.skillIds);
+    this.validateBundleRequired(name, description, skillIds);
+    assertNoSecretLikeText([name, description, ...skillIds]);
+    const duplicate = store.bundles.find((bundle) => bundle.id !== existing.id && bundle.name.toLowerCase() === name.toLowerCase());
+    if (duplicate) throw new Error(`Skill bundle already exists: ${duplicate.id}`);
+    const updated: AgentSkillBundleRecord = {
+      ...existing,
+      name,
+      description,
+      skillIds,
+      provenance: input.provenance === undefined ? existing.provenance : input.provenance.trim() || existing.provenance,
+      reviewState: 'fresh',
+      staleReason: undefined,
+      reviewedAt: undefined,
+      updatedAt: nowIso(),
+    };
+    this.writeStore({
+      ...store,
+      bundles: store.bundles.map((bundle) => bundle.id === existing.id ? updated : bundle),
+    });
+    return updated;
+  }
+
   public setEnabled(idOrName: string, enabled: boolean): AgentSkillRecord {
     const store = this.readStore();
     const existing = this.findInStore(store, idOrName);
@@ -255,6 +404,18 @@ export class AgentSkillRegistry {
     return updated;
   }
 
+  public setBundleEnabled(idOrName: string, enabled: boolean): AgentSkillBundleRecord {
+    const store = this.readStore();
+    const existing = this.findBundleInStore(store, idOrName);
+    if (!existing) throw new Error(`Unknown skill bundle: ${idOrName}`);
+    const updated: AgentSkillBundleRecord = { ...existing, enabled, updatedAt: nowIso() };
+    this.writeStore({
+      ...store,
+      bundles: store.bundles.map((bundle) => bundle.id === existing.id ? updated : bundle),
+    });
+    return updated;
+  }
+
   public markReviewed(idOrName: string): AgentSkillRecord {
     const store = this.readStore();
     const existing = this.findInStore(store, idOrName);
@@ -273,6 +434,24 @@ export class AgentSkillRegistry {
     return updated;
   }
 
+  public markBundleReviewed(idOrName: string): AgentSkillBundleRecord {
+    const store = this.readStore();
+    const existing = this.findBundleInStore(store, idOrName);
+    if (!existing) throw new Error(`Unknown skill bundle: ${idOrName}`);
+    const updated: AgentSkillBundleRecord = {
+      ...existing,
+      reviewState: 'reviewed',
+      staleReason: undefined,
+      reviewedAt: nowIso(),
+      updatedAt: nowIso(),
+    };
+    this.writeStore({
+      ...store,
+      bundles: store.bundles.map((bundle) => bundle.id === existing.id ? updated : bundle),
+    });
+    return updated;
+  }
+
   public markStale(idOrName: string, reason: string): AgentSkillRecord {
     const store = this.readStore();
     const existing = this.findInStore(store, idOrName);
@@ -290,6 +469,23 @@ export class AgentSkillRegistry {
     return updated;
   }
 
+  public markBundleStale(idOrName: string, reason: string): AgentSkillBundleRecord {
+    const store = this.readStore();
+    const existing = this.findBundleInStore(store, idOrName);
+    if (!existing) throw new Error(`Unknown skill bundle: ${idOrName}`);
+    const updated: AgentSkillBundleRecord = {
+      ...existing,
+      reviewState: 'stale',
+      staleReason: reason.trim() || 'Marked stale by user.',
+      updatedAt: nowIso(),
+    };
+    this.writeStore({
+      ...store,
+      bundles: store.bundles.map((bundle) => bundle.id === existing.id ? updated : bundle),
+    });
+    return updated;
+  }
+
   public deleteSkill(idOrName: string): AgentSkillRecord {
     const store = this.readStore();
     const existing = this.findInStore(store, idOrName);
@@ -297,6 +493,20 @@ export class AgentSkillRegistry {
     this.writeStore({
       ...store,
       skills: store.skills.filter((skill) => skill.id !== existing.id),
+      bundles: store.bundles
+        .map((bundle) => ({ ...bundle, skillIds: bundle.skillIds.filter((skillId) => skillId !== existing.id) }))
+        .filter((bundle) => bundle.skillIds.length > 0),
+    });
+    return existing;
+  }
+
+  public deleteBundle(idOrName: string): AgentSkillBundleRecord {
+    const store = this.readStore();
+    const existing = this.findBundleInStore(store, idOrName);
+    if (!existing) throw new Error(`Unknown skill bundle: ${idOrName}`);
+    this.writeStore({
+      ...store,
+      bundles: store.bundles.filter((bundle) => bundle.id !== existing.id),
     });
     return existing;
   }
@@ -307,6 +517,12 @@ export class AgentSkillRegistry {
     if (!procedure) throw new Error('Skill procedure is required.');
   }
 
+  private validateBundleRequired(name: string, description: string, skillIds: readonly string[]): void {
+    if (!name) throw new Error('Skill bundle name is required.');
+    if (!description) throw new Error('Skill bundle description is required.');
+    if (skillIds.length === 0) throw new Error('Skill bundle must include at least one existing skill.');
+  }
+
   private nextId(name: string, skills: readonly AgentSkillRecord[]): string {
     const base = slugify(name);
     const ids = new Set(skills.map((skill) => skill.id));
@@ -318,14 +534,40 @@ export class AgentSkillRegistry {
     throw new Error(`Could not allocate skill id for ${name}.`);
   }
 
+  private nextBundleId(name: string, bundles: readonly AgentSkillBundleRecord[]): string {
+    const base = slugify(name);
+    const ids = new Set(bundles.map((bundle) => bundle.id));
+    if (!ids.has(base)) return base;
+    for (let index = 2; index < 1000; index += 1) {
+      const candidate = `${base}-${index}`;
+      if (!ids.has(candidate)) return candidate;
+    }
+    throw new Error(`Could not allocate skill bundle id for ${name}.`);
+  }
+
   private findInStore(store: SkillStoreFile, idOrName: string): AgentSkillRecord | null {
     const lookup = idOrName.trim().toLowerCase();
     if (!lookup) return null;
     return store.skills.find((skill) => skill.id.toLowerCase() === lookup || skill.name.toLowerCase() === lookup) ?? null;
   }
 
+  private findBundleInStore(store: SkillStoreFile, idOrName: string): AgentSkillBundleRecord | null {
+    const lookup = idOrName.trim().toLowerCase();
+    if (!lookup) return null;
+    return store.bundles.find((bundle) => bundle.id.toLowerCase() === lookup || bundle.name.toLowerCase() === lookup) ?? null;
+  }
+
+  private normalizeExistingSkillIds(store: SkillStoreFile, skillIds: readonly string[]): readonly string[] {
+    const normalized = normalizeList(skillIds).map(slugify);
+    const known = new Set(store.skills.map((skill) => skill.id));
+    for (const skillId of normalized) {
+      if (!known.has(skillId)) throw new Error(`Unknown skill for bundle: ${skillId}`);
+    }
+    return normalized;
+  }
+
   private readStore(): SkillStoreFile {
-    if (!existsSync(this.storePath)) return { version: STORE_VERSION, skills: [] };
+    if (!existsSync(this.storePath)) return { version: STORE_VERSION, skills: [], bundles: [] };
     try {
       return parseStore(readFileSync(this.storePath, 'utf-8'));
     } catch (error) {
@@ -342,13 +584,21 @@ export class AgentSkillRegistry {
 }
 
 export function buildEnabledSkillsPrompt(shellPaths: ShellPathService): string | null {
-  const enabled = AgentSkillRegistry.fromShellPaths(shellPaths).snapshot().enabledSkills;
-  if (enabled.length === 0) return null;
+  const snapshot = AgentSkillRegistry.fromShellPaths(shellPaths).snapshot();
+  const active = snapshot.activeSkills;
+  if (active.length === 0 && snapshot.enabledBundles.length === 0) return null;
   return [
     '## Enabled GoodVibes Agent Skills',
     'Use these local reusable procedures inside the same serial assistant conversation when they fit the user request.',
     '',
-    ...enabled.slice(0, 8).flatMap((skill) => [
+    ...snapshot.enabledBundles.slice(0, 4).flatMap((bundle) => [
+      `### Skill Bundle: ${bundle.name}`,
+      `Description: ${bundle.description}`,
+      `Review state: ${bundle.reviewState}`,
+      `Included skills: ${bundle.skillIds.join(', ')}`,
+      '',
+    ]),
+    ...active.slice(0, 8).flatMap((skill) => [
       `### ${skill.name}`,
       `Description: ${skill.description}`,
       `Review state: ${skill.reviewState}`,

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,
   });
 }

package/src/input/onboarding/onboarding-wizard-steps.ts

@@ -3,6 +3,7 @@ import { modelSelectionLabel, normalizeText } from './onboarding-wizard-helpers.
 import { listAgentRuntimeProfileTemplates } from '../../agent/runtime-profile.ts';
 import type { OnboardingWizardController } from './onboarding-wizard.ts';
 import type { OnboardingWizardActionFieldDefinition, OnboardingWizardFieldDefinition, OnboardingWizardModelPickerFieldDefinition, OnboardingWizardRadioFieldDefinition, OnboardingWizardRadioOption, OnboardingWizardStepDefinition } from './onboarding-wizard-types.ts';
+import type { OnboardingStep1CapabilityId, OnboardingStep1CapabilityItem } from '../../runtime/onboarding/index.ts';
 
 function buildStarterTemplateOptions(): readonly OnboardingWizardRadioOption[] {
   return [
@@ -58,6 +59,98 @@ function addApplyAndContinueAction(step: OnboardingWizardStepDefinition): Onboar
   };
 }
 
+function findRuntimeCapability(
+  controller: OnboardingWizardController,
+  id: OnboardingStep1CapabilityId,
+): OnboardingStep1CapabilityItem | null {
+  return controller.runtimeDerived.step1Capabilities.find((capability) => capability.id === id) ?? null;
+}
+
+function currentMainModelLabel(controller: OnboardingWizardController): string {
+  const routing = controller.runtimeSnapshot?.providerRouting;
+  return modelSelectionLabel(controller.modelSelectionState.get('main') ?? {
+    providerId: normalizeText(routing?.primaryProviderId),
+    modelId: normalizeText(routing?.primaryModelId),
+    enabled: true,
+  });
+}
+
+function profileSetupLabel(controller: OnboardingWizardController): string {
+  const profileName = normalizeText(controller.getStringFieldValue('agent-setup.profile-name', ''));
+  const templateId = controller.getStringFieldValue('agent-setup.profile-template', 'none');
+  if (profileName.length === 0) return 'Current home';
+  return templateId === 'none' ? `Create ${profileName}` : `Create ${profileName} from ${templateId}`;
+}
+
+function buildReviewReadinessFields(controller: OnboardingWizardController): readonly OnboardingWizardFieldDefinition[] {
+  const localBehavior = findRuntimeCapability(controller, 'local-behavior');
+  const channels = findRuntimeCapability(controller, 'communication-channels');
+  const automation = findRuntimeCapability(controller, 'automation-review');
+  const collectionIssues = controller.runtimeSnapshot?.collectionIssues.length ?? 0;
+
+  return [
+    {
+      kind: 'status',
+      id: 'review.readiness.connection',
+      label: 'Runtime connection snapshot',
+      hint: collectionIssues > 0
+        ? `${collectionIssues} setup snapshot issue(s) need attention before this Agent is day-one ready.`
+        : 'The setup snapshot loaded cleanly from the external GoodVibes runtime.',
+      defaultValue: collectionIssues > 0 ? 'Needs attention' : 'Ready',
+      spacerBeforeRows: 1,
+    },
+    {
+      kind: 'status',
+      id: 'review.readiness.model',
+      label: 'Default model route',
+      hint: 'Normal assistant turns use this selected provider/model route unless changed later from the model picker.',
+      defaultValue: currentMainModelLabel(controller),
+    },
+    {
+      kind: 'status',
+      id: 'review.readiness.profile',
+      label: 'Agent profile',
+      hint: 'Profiles isolate Agent-local config, sessions, memory, personas, skills, routines, and setup state.',
+      defaultValue: profileSetupLabel(controller),
+    },
+    {
+      kind: 'status',
+      id: 'review.readiness.knowledge',
+      label: 'Agent Knowledge segment',
+      hint: 'Ask, search, status, and ingest stay on /api/goodvibes-agent/knowledge/* with no default wiki or non-Agent fallback.',
+      defaultValue: 'Isolated',
+    },
+    {
+      kind: 'status',
+      id: 'review.readiness.local-behavior',
+      label: 'Local behavior library',
+      hint: localBehavior?.detail ?? 'Agent-local memory, routines, skills, and personas remain local until a stable shared registry exists.',
+      defaultValue: localBehavior?.selected ? 'Customized' : 'Starter ready',
+    },
+    {
+      kind: 'status',
+      id: 'review.readiness.channels',
+      label: 'Channels and notifications',
+      hint: channels?.detail ?? 'Connect only the channels the Agent should use, and keep outbound delivery explicit.',
+      defaultValue: channels?.selected ? 'Review configured' : 'Optional setup',
+    },
+    {
+      kind: 'status',
+      id: 'review.readiness.automation',
+      label: 'Routines and schedules',
+      hint: automation?.detail ?? 'Local routines run in the main conversation; external schedules require explicit promotion and confirmation.',
+      defaultValue: automation?.selected ? 'Review configured' : 'Local first',
+    },
+    {
+      kind: 'status',
+      id: 'review.readiness.delegation',
+      label: 'Build delegation',
+      hint: 'Build, fix, implementation, and review work is handed to GoodVibes TUI only when explicitly requested.',
+      defaultValue: 'Explicit only',
+    },
+  ];
+}
+
 export function buildCommunicationStep(): OnboardingWizardStepDefinition {
   return {
     id: 'agent-communication',
@@ -636,14 +729,17 @@ export function buildReviewStep(controller: OnboardingWizardController): Onboard
   const unsavedLabel = controller.dirtyStepCount === 1
     ? '1 screen has unapplied changes'
     : `${controller.dirtyStepCount} screens have unapplied changes`;
+  const collectionIssues = controller.runtimeSnapshot?.collectionIssues.length ?? 0;
+  const dayOneReadiness = collectionIssues > 0 ? `${collectionIssues} connection issue(s) before day-one ready` : 'operator checklist ready';
 
   return {
     id: 'review',
     title: 'Review and apply',
     shortLabel: 'Review',
-    description: 'Review Agent-owned settings and apply them directly from the wizard.',
-    summaryTitle: 'Review posture',
+    description: 'Review the Agent day-one checklist and apply setup directly from the wizard.',
+    summaryTitle: 'Agent day-one readiness',
     summaryLines: [
+      `Day-one readiness: ${dayOneReadiness}`,
       unsavedLabel,
       `${controller.buildApplyRequest().operations.length} Agent setting change(s) ready to apply`,
       feedback ? `Last apply: ${feedback.title}` : 'No apply errors reported',
@@ -651,6 +747,7 @@ export function buildReviewStep(controller: OnboardingWizardController): Onboard
     ],
     fields: [
       ...feedbackFields,
+      ...buildReviewReadinessFields(controller),
       {
         kind: 'status',
         id: 'review.global-marker',

package/src/renderer/agent-workspace.ts

@@ -196,10 +196,10 @@ function snapshotLines(workspace: AgentWorkspace, category: AgentWorkspaceCatego
     base.push(
       { text: `GoodVibes runtime: ${snapshot.daemonBaseUrl}`, fg: PALETTE.info },
       { text: `Runtime owner: ${snapshot.daemonOwnership}; Agent connects but never starts or restarts it`, fg: PALETTE.good },
+      ...setupChecklistLines(snapshot),
+      { text: '' },
       { text: `Workspace: ${snapshot.workingDirectory}`, fg: PALETTE.muted },
       { text: `Home: ${snapshot.homeDirectory}`, fg: PALETTE.muted },
-      { text: '' },
-      ...setupChecklistLines(snapshot),
     );
   } else if (category.id === 'channels') {
     const enabledCount = snapshot.channels.filter((channel) => channel.enabled).length;
@@ -283,10 +283,11 @@ function snapshotLines(workspace: AgentWorkspace, category: AgentWorkspaceCatego
     base.push(
       { text: `Active Agent profile: ${snapshot.activeRuntimeProfile}`, fg: PALETTE.info },
       { text: `Agent profiles under this home: ${snapshot.runtimeProfileCount}`, fg: PALETTE.info },
-      { text: `Agent profile root: ${snapshot.runtimeProfileRoot}`, fg: PALETTE.muted },
       { text: `Starter templates: ${snapshot.runtimeStarterTemplateCount}; local custom: ${snapshot.localStarterTemplateCount}`, fg: PALETTE.info },
       { text: `Config profiles: ${snapshot.configProfileCount}`, fg: PALETTE.info },
       { text: `Starter ids: ${snapshot.runtimeStarterTemplates.map((template) => template.id).join(', ') || 'none'}`, fg: PALETTE.info },
+      { text: 'Starter Templates', fg: PALETTE.title, bold: true },
+      { text: `Agent profile root: ${snapshot.runtimeProfileRoot}`, fg: PALETTE.muted },
       { text: '' },
       ...profileLines(snapshot),
       { text: '' },
@@ -301,7 +302,7 @@ function snapshotLines(workspace: AgentWorkspace, category: AgentWorkspaceCatego
     base.push(
       { text: `Session memories: ${snapshot.sessionMemoryCount}`, fg: PALETTE.info },
       { text: `Local routines: ${snapshot.localRoutineCount}; enabled: ${snapshot.enabledRoutineCount}`, fg: PALETTE.info },
-      { text: `Local skills: ${snapshot.localSkillCount}; enabled: ${snapshot.enabledSkillCount}`, fg: PALETTE.info },
+      { text: `Local skills: ${snapshot.localSkillCount}; enabled: ${snapshot.enabledSkillCount}; bundles: ${snapshot.localSkillBundleCount}; active skills: ${snapshot.activeSkillCount}`, fg: PALETTE.info },
       { text: `Local personas: ${snapshot.localPersonaCount}; active: ${snapshot.activePersonaName}`, fg: PALETTE.info },
       { text: 'Durable memory, routines, skills, and personas remain Agent-local until shared registry contracts exist.', fg: PALETTE.good },
       { text: 'Secrets are rejected/redacted; store secret references instead of secret values.', fg: PALETTE.warn },
@@ -316,11 +317,13 @@ function snapshotLines(workspace: AgentWorkspace, category: AgentWorkspaceCatego
     );
   } else if (category.id === 'skills') {
     base.push(
-      { text: `Skills: ${snapshot.localSkillCount}; enabled: ${snapshot.enabledSkillCount}`, fg: PALETTE.info },
+      { text: `Skills: ${snapshot.localSkillCount}; enabled: ${snapshot.enabledSkillCount}; bundles: ${snapshot.localSkillBundleCount}; enabled bundles: ${snapshot.enabledSkillBundleCount}; active skills: ${snapshot.activeSkillCount}`, fg: PALETTE.info },
       { text: 'Skills are reusable local procedures the assistant can apply from the main conversation.', fg: PALETTE.good },
-      { text: 'Enabled skills are injected as operating guidance; secret-looking content is rejected.', fg: PALETTE.warn },
+      { text: 'Enabled skills and enabled bundles are injected as operating guidance; secret-looking content is rejected.', fg: PALETTE.warn },
       { text: '' },
       ...localLibraryLines('Skill Library', snapshot.localSkills, 'No local skills yet. Create one here with Create skill.', workspace.selectedLocalLibraryItem('skill')?.id ?? null),
+      { text: '' },
+      ...localLibraryLines('Skill Bundles', snapshot.localSkillBundles, 'No local skill bundles yet. Use Skill bundles and Create bundle after creating skills.', null),
     );
   } else if (category.id === 'routines') {
     base.push(

package/src/version.ts

@@ -6,7 +6,7 @@ import { join } from 'node:path';
 // The prebuild script updates the fallback value before compilation.
 // Uses import.meta.dir (Bun) to locate package.json relative to this file,
 // which is correct regardless of the process working directory.
-let _version = '0.1.79';
+let _version = '0.1.81';
 let _sdkVersion = '0.33.35';
 try {
   const pkg = JSON.parse(readFileSync(join(import.meta.dir, '..', 'package.json'), 'utf-8')) as {