@pellux/goodvibes-agent 0.1.80 → 0.1.82

package/CHANGELOG.md

@@ -2,6 +2,17 @@
 
 All notable changes to GoodVibes Agent will be recorded here.
 
+## 0.1.82 - 2026-06-01
+
+- 3185531 Remove Agent local auth ownership paths
+
+## 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.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pellux/goodvibes-agent",
-  "version": "0.1.80",
+  "version": "0.1.82",
   "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/cli/help.ts

@@ -38,7 +38,7 @@ export function renderGoodVibesHelp(binary = 'goodvibes-agent'): string {
     '  providers                  List/inspect/use provider config/auth posture',
     '  profiles                   Manage isolated Agent profile homes',
     '  routines                   Inspect local routines and explicitly promote one to an external schedule',
-    '  auth                       Inspect and manage local users, sessions, and bootstrap auth',
+    '  auth                       Inspect Agent auth posture and external runtime token state',
     '  compat                     Inspect Agent SDK pin, runtime version, and Agent knowledge route readiness',
     '  knowledge                  Use isolated Agent Knowledge/Wiki routes',
     '  ask|search                 Shortcuts for isolated Agent Knowledge ask/search',
@@ -170,9 +170,9 @@ const COMMAND_HELP: Record<string, CommandHelp> = {
     examples: ['models current', 'models openai', 'models use openai:gpt-5.4'],
   },
   auth: {
-    usage: ['auth status', 'auth users', 'auth sessions', 'auth add-user <username>', 'auth clear-bootstrap'],
-    summary: 'Inspect and manage local admin users, bootstrap auth, and local sessions.',
-    examples: ['auth', 'auth add-user admin --password-stdin', 'auth clear-bootstrap'],
+    usage: ['auth', 'auth status', 'auth review', 'auth users', 'auth sessions'],
+    summary: 'Inspect Agent auth posture and external runtime token state. Runtime user/session administration belongs to the runtime-owning TUI or host tooling.',
+    examples: ['auth', 'auth status', 'auth users'],
   },
   compat: {
     usage: ['compat', 'compat --json'],