@pellux/goodvibes-agent 0.1.116 → 0.1.117

package/src/agent/routine-schedule-receipts.ts

@@ -477,7 +477,7 @@ export async function reconcileRoutineScheduleReceipts(
     return {
       ok: false,
       kind: 'auth_required',
-      error: `No daemon operator token found at ${connection.tokenPath}`,
+      error: `No connected-host operator token found at ${connection.tokenPath}`,
       route: ROUTINE_SCHEDULE_ROUTE,
       baseUrl: connection.baseUrl,
     };

package/src/agent/runtime-profile-starters.ts

@@ -44,7 +44,7 @@ export const STARTER_TEMPLATES: readonly AgentRuntimeProfileStarterTemplate[] =
       body: [
         'Operate as a calm household coordinator.',
         'Track preferences, routines, device/service notes, and recurring decisions in Agent-local memory after they are durable and non-secret.',
-        'Use read-only daemon/operator routes for status checks. Require explicit approval for purchases, messages to other people, service changes, deletions, or secret handling.',
+        'Use read-only connected-host/operator routes for status checks. Require explicit approval for purchases, messages to other people, service changes, deletions, or secret handling.',
         'Keep replies concrete: next action, owner, date, and open question when one is needed.',
       ].join('\n'),
       tags: ['household', 'home', 'coordination'],
@@ -223,7 +223,7 @@ export const STARTER_TEMPLATES: readonly AgentRuntimeProfileStarterTemplate[] =
       description: 'Operator persona for systems, incidents, runbooks, approvals, and service posture.',
       body: [
         'Favor explicit state, logs, health, approvals, and next action.',
-        'Use read-only daemon/operator routes by default.',
+        'Use read-only connected-host/operator routes by default.',
         'Require explicit confirmation for run, pause, resume, cancel, retry, approve, deny, service changes, or writes.',
         'Delegate code/build fixes to GoodVibes TUI when explicitly requested.',
       ].join('\n'),
@@ -260,7 +260,7 @@ export const STARTER_TEMPLATES: readonly AgentRuntimeProfileStarterTemplate[] =
         name: 'Daily Operations Sweep',
         description: 'Inspect service posture, pending approvals, failed runs, and stale tasks.',
         steps: [
-          '1. Refresh daemon status, compat, approvals, workplan, automation snapshot, runs, schedules, and capacity.',
+          '1. Refresh connected-host status, compat, approvals, workplan, automation snapshot, runs, schedules, and capacity.',
           '2. Summarize degraded items and blocked work.',
           '3. Recommend exact follow-up commands with confirmation gates for side effects.',
         ].join('\n'),

package/src/agent/runtime-profile.ts

@@ -36,6 +36,12 @@ export interface AgentRuntimeProfileInfo extends AgentRuntimeProfileResolution {
   readonly starterTemplateApplication?: AgentRuntimeProfileTemplateApplication;
 }
 
+export interface AgentRuntimeProfileSelection extends AgentRuntimeProfileResolution {
+  readonly selectedAt: string | null;
+  readonly path: string;
+  readonly exists: boolean;
+}
+
 export interface AgentRuntimeProfileTemplateApplication {
   readonly id: AgentRuntimeProfileTemplateId;
   readonly name: string;
@@ -76,11 +82,14 @@ export interface AgentRuntimeProfileCommandResult {
     | 'agent.profiles.template.from_discovered'
     | 'agent.profiles.create_from_discovered'
     | 'agent.profiles.create'
+    | 'agent.profiles.default'
+    | 'agent.profiles.default.clear'
     | 'agent.profiles.delete'
     | 'agent.profiles.error';
   readonly data?: {
     readonly profiles?: readonly AgentRuntimeProfileInfo[];
     readonly profile?: AgentRuntimeProfileInfo;
+    readonly selectedProfile?: AgentRuntimeProfileSelection;
     readonly templates?: readonly AgentRuntimeProfileTemplateSummary[];
     readonly appliedTemplate?: AgentRuntimeProfileTemplateApplication;
     readonly template?: AgentRuntimeProfileTemplateSummary;
@@ -91,6 +100,7 @@ export interface AgentRuntimeProfileCommandResult {
 }
 
 const PROFILE_CREATED_FILE = 'profile.json';
+const PROFILE_SELECTION_FILE = 'profile-selection.json';
 const PROFILE_ID_PATTERN = /^[a-z0-9](?:[a-z0-9._-]{0,62}[a-z0-9])?$/;
 
 export function normalizeAgentRuntimeProfileId(value: string): string {
@@ -122,6 +132,10 @@ export function getAgentRuntimeProfileTemplatesRoot(baseHomeDirectory: string):
   return join(baseHomeDirectory, '.goodvibes', GOODVIBES_AGENT_SURFACE_ROOT, 'profile-starters');
 }
 
+export function getAgentRuntimeProfileSelectionPath(baseHomeDirectory: string): string {
+  return join(baseHomeDirectory, '.goodvibes', GOODVIBES_AGENT_SURFACE_ROOT, PROFILE_SELECTION_FILE);
+}
+
 export function resolveAgentRuntimeProfileHome(baseHomeDirectory: string, profileName: string): AgentRuntimeProfileResolution {
   const id = assertValidAgentRuntimeProfileId(profileName);
   return {
@@ -130,6 +144,37 @@ export function resolveAgentRuntimeProfileHome(baseHomeDirectory: string, profil
   };
 }
 
+export function readAgentRuntimeProfileSelection(baseHomeDirectory: string): AgentRuntimeProfileSelection | null {
+  const path = getAgentRuntimeProfileSelectionPath(baseHomeDirectory);
+  if (!existsSync(path)) return null;
+  try {
+    const raw: unknown = JSON.parse(readFileSync(path, 'utf-8'));
+    if (!raw || typeof raw !== 'object' || Array.isArray(raw)) return null;
+    const record = raw as Record<string, unknown>;
+    const profileId = record.profileId;
+    if (typeof profileId !== 'string') return null;
+    const resolution = resolveAgentRuntimeProfileHome(baseHomeDirectory, profileId);
+    const selectedAt = typeof record.selectedAt === 'string' ? record.selectedAt : null;
+    return {
+      ...resolution,
+      selectedAt,
+      path,
+      exists: existsSync(resolution.homeDirectory),
+    };
+  } catch {
+    return null;
+  }
+}
+
+export function resolveSelectedAgentRuntimeProfileHome(baseHomeDirectory: string): AgentRuntimeProfileResolution | null {
+  const selection = readAgentRuntimeProfileSelection(baseHomeDirectory);
+  if (!selection?.exists) return null;
+  return {
+    id: selection.id,
+    homeDirectory: selection.homeDirectory,
+  };
+}
+
 function readProfileCreatedAt(homeDirectory: string): string | null {
   const path = join(homeDirectory, PROFILE_CREATED_FILE);
   if (!existsSync(path)) return null;
@@ -573,9 +618,42 @@ export function createAgentRuntimeProfile(baseHomeDirectory: string, profileName
   };
 }
 
+export function setAgentRuntimeProfileSelection(baseHomeDirectory: string, profileName: string): AgentRuntimeProfileSelection {
+  const resolution = resolveAgentRuntimeProfileHome(baseHomeDirectory, profileName);
+  if (!existsSync(resolution.homeDirectory)) {
+    throw new Error(`Agent profile not found: ${resolution.id}`);
+  }
+  const path = getAgentRuntimeProfileSelectionPath(baseHomeDirectory);
+  mkdirSync(dirname(path), { recursive: true });
+  const selectedAt = new Date().toISOString();
+  writeFileSync(
+    path,
+    `${JSON.stringify({
+      profileId: resolution.id,
+      selectedAt,
+    }, null, 2)}\n`,
+    'utf-8',
+  );
+  return {
+    ...resolution,
+    selectedAt,
+    path,
+    exists: true,
+  };
+}
+
+export function clearAgentRuntimeProfileSelection(baseHomeDirectory: string): boolean {
+  const path = getAgentRuntimeProfileSelectionPath(baseHomeDirectory);
+  if (!existsSync(path)) return false;
+  rmSync(path, { force: true });
+  return true;
+}
+
 export function deleteAgentRuntimeProfile(baseHomeDirectory: string, profileName: string): boolean {
   const resolution = resolveAgentRuntimeProfileHome(baseHomeDirectory, profileName);
   if (!existsSync(resolution.homeDirectory)) return false;
   rmSync(resolution.homeDirectory, { recursive: true, force: true });
+  const selection = readAgentRuntimeProfileSelection(baseHomeDirectory);
+  if (selection?.id === resolution.id) clearAgentRuntimeProfileSelection(baseHomeDirectory);
   return true;
 }

package/src/agent/skill-registry.ts

@@ -1,11 +1,31 @@
-import { existsSync, mkdirSync, readFileSync, renameSync, writeFileSync } from 'node:fs';
-import { dirname } from 'node:path';
+import { accessSync, constants, existsSync, mkdirSync, readFileSync, renameSync, writeFileSync } from 'node:fs';
+import { delimiter, dirname, join } from 'node:path';
 import type { ShellPathService } from '@/runtime/index.ts';
 import { GOODVIBES_AGENT_SURFACE_ROOT } from '../config/surface.ts';
 import { assertNoSecretLikeText } from './persona-registry.ts';
 
 export type AgentSkillSource = 'user' | 'agent' | 'imported' | 'system';
 export type AgentSkillReviewState = 'fresh' | 'reviewed' | 'stale';
+export type AgentSkillRequirementKind = 'env' | 'command';
+
+export interface AgentSkillRequirement {
+  readonly kind: AgentSkillRequirementKind;
+  readonly name: string;
+  readonly description?: string;
+}
+
+export interface AgentSkillReadiness {
+  readonly ready: boolean;
+  readonly met: readonly AgentSkillRequirement[];
+  readonly missing: readonly AgentSkillRequirement[];
+}
+
+export interface AgentSkillBundleReadiness {
+  readonly ready: boolean;
+  readonly includedSkills: readonly AgentSkillRecord[];
+  readonly missingSkillIds: readonly string[];
+  readonly missingRequirements: readonly AgentSkillRequirement[];
+}
 
 export interface AgentSkillRecord {
   readonly id: string;
@@ -14,6 +34,7 @@ export interface AgentSkillRecord {
   readonly procedure: string;
   readonly triggers: readonly string[];
   readonly tags: readonly string[];
+  readonly requirements: readonly AgentSkillRequirement[];
   readonly enabled: boolean;
   readonly source: AgentSkillSource;
   readonly provenance: string;
@@ -45,6 +66,7 @@ export interface AgentSkillCreateInput {
   readonly procedure: string;
   readonly triggers?: readonly string[];
   readonly tags?: readonly string[];
+  readonly requirements?: readonly AgentSkillRequirement[];
   readonly enabled?: boolean;
   readonly source?: AgentSkillSource;
   readonly provenance?: string;
@@ -65,6 +87,7 @@ export interface AgentSkillUpdateInput {
   readonly procedure?: string;
   readonly triggers?: readonly string[];
   readonly tags?: readonly string[];
+  readonly requirements?: readonly AgentSkillRequirement[];
   readonly provenance?: string;
 }
 
@@ -105,6 +128,11 @@ function readStringArray(value: unknown): string[] {
   return value.filter((entry): entry is string => typeof entry === 'string').map((entry) => entry.trim()).filter(Boolean);
 }
 
+function readRequirementKind(value: unknown): AgentSkillRequirementKind | null {
+  if (value === 'env' || value === 'command') return value;
+  return null;
+}
+
 function normalizeName(name: string): string {
   return name.trim().replace(/\s+/g, ' ');
 }
@@ -123,6 +151,48 @@ function normalizeList(values: readonly string[] | undefined): string[] {
   return result;
 }
 
+function validateRequirementName(requirement: AgentSkillRequirement): void {
+  if (requirement.kind === 'env' && !/^[A-Za-z_][A-Za-z0-9_]*$/.test(requirement.name)) {
+    throw new Error(`Invalid skill env requirement: ${requirement.name}`);
+  }
+  if (requirement.kind === 'command' && !/^[A-Za-z0-9._+-]+$/.test(requirement.name)) {
+    throw new Error(`Invalid skill command requirement: ${requirement.name}`);
+  }
+}
+
+function normalizeRequirements(values: readonly AgentSkillRequirement[] | undefined): AgentSkillRequirement[] {
+  const seen = new Set<string>();
+  const result: AgentSkillRequirement[] = [];
+  for (const value of values ?? []) {
+    const kind = readRequirementKind(value.kind);
+    const name = typeof value.name === 'string' ? value.name.trim() : '';
+    if (!kind || !name) continue;
+    const description = typeof value.description === 'string' ? value.description.trim() : '';
+    const requirement: AgentSkillRequirement = {
+      kind,
+      name,
+      ...(description ? { description } : {}),
+    };
+    validateRequirementName(requirement);
+    const key = `${requirement.kind}:${requirement.name.toLowerCase()}`;
+    if (seen.has(key)) continue;
+    seen.add(key);
+    result.push(requirement);
+  }
+  return result;
+}
+
+function parseRequirements(value: unknown): AgentSkillRequirement[] {
+  if (!Array.isArray(value)) return [];
+  return normalizeRequirements(value
+    .filter(isRecord)
+    .map((entry) => ({
+      kind: readRequirementKind(entry.kind) ?? 'env',
+      name: readString(entry.name).trim(),
+      description: readString(entry.description).trim(),
+    })));
+}
+
 function slugify(value: string): string {
   const slug = value.trim().toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/^-+|-+$/g, '');
   return slug || 'skill';
@@ -132,6 +202,23 @@ function nowIso(): string {
   return new Date().toISOString();
 }
 
+function canExecute(path: string): boolean {
+  try {
+    accessSync(path, constants.X_OK);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function commandExists(command: string, pathValue: string | undefined): boolean {
+  if (!pathValue) return false;
+  return pathValue
+    .split(delimiter)
+    .filter(Boolean)
+    .some((pathEntry) => canExecute(join(pathEntry, command)));
+}
+
 function parseSkill(value: unknown): AgentSkillRecord | null {
   if (!isRecord(value)) return null;
   const id = readString(value.id).trim();
@@ -150,6 +237,7 @@ function parseSkill(value: unknown): AgentSkillRecord | null {
     procedure,
     triggers: readStringArray(value.triggers),
     tags: readStringArray(value.tags),
+    requirements: parseRequirements(value.requirements),
     enabled: value.enabled === true,
     source,
     provenance: readString(value.provenance, source).trim() || source,
@@ -206,14 +294,16 @@ function formatStore(store: SkillStoreFile): string {
   return `${JSON.stringify(store, null, 2)}\n`;
 }
 
-export function skillStorePath(shellPaths: ShellPathService): string {
+type AgentLocalStorePaths = Pick<ShellPathService, 'resolveUserPath'>;
+
+export function skillStorePath(shellPaths: AgentLocalStorePaths): string {
   return shellPaths.resolveUserPath(GOODVIBES_AGENT_SURFACE_ROOT, 'skills', 'skills.json');
 }
 
 export class AgentSkillRegistry {
   public constructor(private readonly storePath: string) {}
 
-  public static fromShellPaths(shellPaths: ShellPathService): AgentSkillRegistry {
+  public static fromShellPaths(shellPaths: AgentLocalStorePaths): AgentSkillRegistry {
     return new AgentSkillRegistry(skillStorePath(shellPaths));
   }
 
@@ -284,7 +374,8 @@ export class AgentSkillRegistry {
     const description = input.description.trim();
     const procedure = input.procedure.trim();
     this.validateRequired(name, description, procedure);
-    assertNoSecretLikeText([name, description, procedure, ...(input.tags ?? []), ...(input.triggers ?? [])]);
+    const requirements = normalizeRequirements(input.requirements);
+    assertNoSecretLikeText([name, description, procedure, ...(input.tags ?? []), ...(input.triggers ?? []), ...requirements.flatMap((requirement) => [requirement.name, requirement.description ?? ''])]);
     const duplicate = store.skills.find((skill) => skill.name.toLowerCase() === name.toLowerCase());
     if (duplicate) throw new Error(`Skill already exists: ${duplicate.id}`);
     const timestamp = nowIso();
@@ -295,6 +386,7 @@ export class AgentSkillRegistry {
       procedure,
       triggers: normalizeList(input.triggers),
       tags: normalizeList(input.tags),
+      requirements,
       enabled: input.enabled === true,
       source: input.source ?? 'user',
       provenance: input.provenance?.trim() || input.source || 'user',
@@ -340,7 +432,8 @@ export class AgentSkillRegistry {
     const description = input.description === undefined ? existing.description : input.description.trim();
     const procedure = input.procedure === undefined ? existing.procedure : input.procedure.trim();
     this.validateRequired(name, description, procedure);
-    assertNoSecretLikeText([name, description, procedure, ...(input.tags ?? []), ...(input.triggers ?? [])]);
+    const requirements = input.requirements === undefined ? existing.requirements : normalizeRequirements(input.requirements);
+    assertNoSecretLikeText([name, description, procedure, ...(input.tags ?? []), ...(input.triggers ?? []), ...requirements.flatMap((requirement) => [requirement.name, requirement.description ?? ''])]);
     const duplicate = store.skills.find((skill) => skill.id !== existing.id && skill.name.toLowerCase() === name.toLowerCase());
     if (duplicate) throw new Error(`Skill already exists: ${duplicate.id}`);
     const updated: AgentSkillRecord = {
@@ -350,6 +443,7 @@ export class AgentSkillRegistry {
       procedure,
       triggers: input.triggers === undefined ? existing.triggers : normalizeList(input.triggers),
       tags: input.tags === undefined ? existing.tags : normalizeList(input.tags),
+      requirements,
       provenance: input.provenance === undefined ? existing.provenance : input.provenance.trim() || existing.provenance,
       reviewState: 'fresh',
       staleReason: undefined,
@@ -583,6 +677,80 @@ export class AgentSkillRegistry {
   }
 }
 
+export function buildAgentSkillRequirements(input: {
+  readonly env?: readonly string[];
+  readonly commands?: readonly string[];
+}): readonly AgentSkillRequirement[] {
+  return normalizeRequirements([
+    ...(input.env ?? []).map((name) => ({ kind: 'env' as const, name })),
+    ...(input.commands ?? []).map((name) => ({ kind: 'command' as const, name })),
+  ]);
+}
+
+export function normalizeAgentSkillRequirements(values: readonly AgentSkillRequirement[] | undefined): readonly AgentSkillRequirement[] {
+  return normalizeRequirements(values);
+}
+
+export function formatAgentSkillRequirement(requirement: AgentSkillRequirement): string {
+  return `${requirement.kind}:${requirement.name}`;
+}
+
+export function evaluateAgentSkillReadiness(
+  skill: Pick<AgentSkillRecord, 'requirements'>,
+  options: {
+    readonly env?: Readonly<Record<string, string | undefined>>;
+    readonly pathValue?: string;
+  } = {},
+): AgentSkillReadiness {
+  const env = options.env ?? process.env;
+  const pathValue = options.pathValue ?? env.PATH;
+  const met: AgentSkillRequirement[] = [];
+  const missing: AgentSkillRequirement[] = [];
+  for (const requirement of skill.requirements) {
+    const present = requirement.kind === 'env'
+      ? typeof env[requirement.name] === 'string' && (env[requirement.name] ?? '').length > 0
+      : commandExists(requirement.name, pathValue);
+    if (present) met.push(requirement);
+    else missing.push(requirement);
+  }
+  return { ready: missing.length === 0, met, missing };
+}
+
+export function evaluateAgentSkillBundleReadiness(
+  bundle: Pick<AgentSkillBundleRecord, 'skillIds'>,
+  skills: readonly AgentSkillRecord[],
+  options: {
+    readonly env?: Readonly<Record<string, string | undefined>>;
+    readonly pathValue?: string;
+  } = {},
+): AgentSkillBundleReadiness {
+  const skillById = new Map(skills.map((skill) => [skill.id, skill]));
+  const includedSkills: AgentSkillRecord[] = [];
+  const missingSkillIds: string[] = [];
+  const missingRequirements: AgentSkillRequirement[] = [];
+  const seenRequirements = new Set<string>();
+  for (const skillId of bundle.skillIds) {
+    const skill = skillById.get(skillId);
+    if (!skill) {
+      missingSkillIds.push(skillId);
+      continue;
+    }
+    includedSkills.push(skill);
+    for (const requirement of evaluateAgentSkillReadiness(skill, options).missing) {
+      const key = `${requirement.kind}:${requirement.name.toLowerCase()}`;
+      if (seenRequirements.has(key)) continue;
+      seenRequirements.add(key);
+      missingRequirements.push(requirement);
+    }
+  }
+  return {
+    ready: missingSkillIds.length === 0 && missingRequirements.length === 0,
+    includedSkills,
+    missingSkillIds,
+    missingRequirements,
+  };
+}
+
 export function buildEnabledSkillsPrompt(shellPaths: ShellPathService): string | null {
   const snapshot = AgentSkillRegistry.fromShellPaths(shellPaths).snapshot();
   const active = snapshot.activeSkills;
@@ -591,18 +759,27 @@ export function buildEnabledSkillsPrompt(shellPaths: ShellPathService): string |
     '## Enabled GoodVibes Agent Skills',
     'Use these local reusable procedures inside the same serial assistant conversation when they fit the user request.',
     '',
-    ...snapshot.enabledBundles.slice(0, 4).flatMap((bundle) => [
-      `### Skill Bundle: ${bundle.name}`,
-      `Description: ${bundle.description}`,
-      `Review state: ${bundle.reviewState}`,
-      `Included skills: ${bundle.skillIds.join(', ')}`,
-      '',
-    ]),
+    ...snapshot.enabledBundles.slice(0, 4).flatMap((bundle) => {
+      const readiness = evaluateAgentSkillBundleReadiness(bundle, snapshot.skills);
+      const missing = [
+        ...readiness.missingRequirements.map(formatAgentSkillRequirement),
+        ...readiness.missingSkillIds.map((skillId) => `skill:${skillId}`),
+      ];
+      return [
+        `### Skill Bundle: ${bundle.name}`,
+        `Description: ${bundle.description}`,
+        `Review state: ${bundle.reviewState}`,
+        `Readiness: ${readiness.ready ? 'ready' : `missing ${missing.join(', ')}`}`,
+        `Included skills: ${bundle.skillIds.join(', ')}`,
+        '',
+      ];
+    }),
     ...active.slice(0, 8).flatMap((skill) => [
       `### ${skill.name}`,
       `Description: ${skill.description}`,
       `Review state: ${skill.reviewState}`,
       `Triggers: ${skill.triggers.join(', ') || '(manual)'}`,
+      `Readiness: ${evaluateAgentSkillReadiness(skill).ready ? 'ready' : `missing ${evaluateAgentSkillReadiness(skill).missing.map(formatAgentSkillRequirement).join(', ')}`}`,
       skill.procedure,
       '',
     ]),

package/src/cli/agent-knowledge-command.ts

@@ -493,7 +493,7 @@ export async function handleCompatCommand(runtime: CliCommandRuntime): Promise<C
     ok: versionCompatible && knowledgeRouteReady,
     packageVersion: metadata.version,
     sdkPin: metadata.sdkVersion,
-    daemon: {
+    connectedHost: {
       baseUrl: connection.baseUrl,
       status: daemon.status,
       version: daemonVersion,
@@ -518,7 +518,7 @@ export async function handleCompatCommand(runtime: CliCommandRuntime): Promise<C
     `  version compatible: ${yesNo(versionCompatible)}`,
     `  operator token: ${connection.token ? 'present' : 'missing'} (${connection.tokenPath})`,
     `  Agent knowledge route: ${knowledgeRouteReady ? 'ready' : `not ready (${knowledgeRoute.ok ? 'unknown' : knowledgeRoute.kind})`}`,
-    ...(versionCompatible ? [] : ['  next: update connected GoodVibes services so /status matches the Agent SDK pin.']),
+    ...(versionCompatible ? [] : ['  next: update the connected GoodVibes host so /status matches the Agent SDK pin.']),
   ].join('\n');
   return {
     output: runtime.cli.flags.outputFormat === 'json' ? JSON.stringify(value, null, 2) : text,

package/src/cli/agent-knowledge-format.ts

@@ -367,10 +367,10 @@ export function formatFailure(failure: AgentKnowledgeFailureLike, json: boolean)
       ? `  versions: runtime=${failure.daemonVersion} expected=${failure.expectedSdkVersion}`
       : null,
     failure.kind === 'version_mismatch'
-      ? '  next: update connected GoodVibes services so /status matches the Agent SDK pin.'
+      ? '  next: update the connected GoodVibes host so /status matches the Agent SDK pin.'
       : null,
     failure.kind === 'daemon_route_unavailable'
-      ? '  next: update connected GoodVibes services to the SDK version required by this Agent package.'
+      ? '  next: update the connected GoodVibes host to the SDK version required by this Agent package.'
       : null,
   ].filter((line): line is string => Boolean(line)).join('\n');
 }

package/src/cli/agent-knowledge-runtime.ts

@@ -94,7 +94,7 @@ export async function classifyKnowledgeError(error: unknown, connection: AgentDa
       return {
         ok: false,
         kind: 'version_mismatch',
-        error: `Connected GoodVibes service SDK version ${daemonVersion} does not match Agent SDK pin ${metadata.sdkVersion}; Agent Knowledge route is unavailable.`,
+        error: `Connected GoodVibes host SDK version ${daemonVersion} does not match Agent SDK pin ${metadata.sdkVersion}; Agent Knowledge route is unavailable.`,
         baseUrl: connection.baseUrl,
         route,
         daemonVersion,

package/src/cli/bundle-command.ts

@@ -132,7 +132,7 @@ export async function handleBundleCommand(runtime: CliCommandRuntime): Promise<C
     const summary = inspectBundle(sourcePath, parsed.value);
     return {
       output: formatJsonOrText(runtime, summary, [
-        'GoodVibes bundle',
+        'GoodVibes Agent support bundle',
         `  type: ${summary.type}`,
         `  version: ${summary.version}`,
         `  path: ${summary.path}`,

package/src/cli/entrypoint.ts

@@ -25,7 +25,7 @@ import {
 import { buildCliServicePosture } from './service-posture.ts';
 import { inspectCliExternalRuntime } from './external-runtime.ts';
 import { GOODVIBES_AGENT_SURFACE_ROOT } from '../config/surface.ts';
-import { resolveAgentRuntimeProfileHome } from '../agent/runtime-profile.ts';
+import { resolveAgentRuntimeProfileHome, resolveSelectedAgentRuntimeProfileHome } from '../agent/runtime-profile.ts';
 
 type ShellEntrypointOwnership = {
   readonly workingDirectory: string;
@@ -52,14 +52,20 @@ export type PreparedShellCliRuntime = {
   readonly bootstrapHomeDirectory: string;
 };
 
-function resolveShellEntrypointOwnership(
+export function resolveShellEntrypointOwnership(
   roots: ShellEntrypointRoots,
   workingDirOverride?: string,
-  agentProfile?: string,
+  options: {
+    readonly agentProfile?: string;
+    readonly useSelectedProfile: boolean;
+  } = { useSelectedProfile: true },
 ): ShellEntrypointOwnership {
-  const homeDirectory = agentProfile
-    ? resolveAgentRuntimeProfileHome(roots.homeDirectory, agentProfile).homeDirectory
-    : roots.homeDirectory;
+  const selectedProfile = options.agentProfile
+    ? resolveAgentRuntimeProfileHome(roots.homeDirectory, options.agentProfile)
+    : options.useSelectedProfile
+      ? resolveSelectedAgentRuntimeProfileHome(roots.homeDirectory)
+      : null;
+  const homeDirectory = selectedProfile?.homeDirectory ?? roots.homeDirectory;
   return {
     workingDirectory: workingDirOverride ?? roots.defaultWorkingDirectory,
     homeDirectory,
@@ -103,7 +109,10 @@ export async function prepareShellCliRuntime(
     ownership = resolveShellEntrypointOwnership(
       roots,
       cli.flags.workingDir ?? (cli.command === 'tui' ? cli.commandArgs[0] : undefined),
-      cli.command === 'profiles' ? undefined : cli.flags.agentProfile,
+      {
+        agentProfile: cli.command === 'profiles' ? undefined : cli.flags.agentProfile,
+        useSelectedProfile: cli.command !== 'profiles',
+      },
     );
   } catch (error) {
     console.error(error instanceof Error ? error.message : String(error));