@pellux/goodvibes-agent 0.1.27 → 0.1.29

package/CHANGELOG.md

@@ -2,6 +2,14 @@
 
 All notable changes to GoodVibes Agent will be recorded here.
 
+## 0.1.29 - 2026-05-31
+
+- 3fafcda Add Agent channel workspace guidance
+
+## 0.1.28 - 2026-05-31
+
+- 77a9dc4 Add isolated Agent runtime profiles
+
 ## 0.1.27 - 2026-05-31
 
 - b5be172 Add capabilities CLI handler

package/README.md

@@ -46,6 +46,16 @@ Inside the Agent TUI, use `/agent`, `/home`, or `/operator` to open the operator
 
 Use `goodvibes-agent capabilities` or `/capabilities` to inspect the OpenClaw/Hermes benchmark, current Agent posture, configuration commands, usage paths, and remaining gaps.
 
+Use isolated Agent runtime profiles when one machine needs separate operator identities or local state:
+
+```sh
+goodvibes-agent profiles create household --yes
+goodvibes-agent --agent-profile household status
+GOODVIBES_AGENT_HOME=/path/to/agent-home goodvibes-agent status
+```
+
+Profiles isolate Agent-local config, sessions, local memory, personas, skills, routines, and setup state. The daemon is still external and shared unless your daemon host is separately configured otherwise.
+
 Local Agent behavior is editable from the TUI:
 
 ```text

package/docs/README.md

@@ -20,6 +20,7 @@ Important baseline constraints:
 - Agent does not start, stop, restart, install, uninstall, or own daemon/listener/web/service lifecycle.
 - Agent Knowledge/Wiki uses only `/api/goodvibes-agent/knowledge/*`; there is no default Knowledge/Wiki, HomeGraph, or Home Assistant fallback.
 - Agent exposes `goodvibes-agent capabilities` and `/capabilities` to compare OpenClaw/Hermes capability targets against current Agent readiness and configuration paths.
+- Agent supports isolated runtime homes with `GOODVIBES_AGENT_HOME=<path>` and named profile homes with `goodvibes-agent profiles create <name> --yes` plus `--agent-profile <name>`.
 - Local personas, routines, and Agent skills are stored under the Agent surface root and are injected only into the serial Agent conversation.
 - Normal assistant chat is not coding-session delegation.
 - Build/fix/review delegation to GoodVibes TUI must be explicit; WRFC is not the default Agent behavior.

package/docs/getting-started.md

@@ -1,6 +1,6 @@
 # Getting Started
 
-GoodVibes Agent `0.1.9` is the current installable public alpha of the personal operator assistant built on the GoodVibes TUI foundation.
+GoodVibes Agent is the installable public alpha of the personal operator assistant built on the GoodVibes TUI foundation.
 
 ## Requirements
 
@@ -37,6 +37,24 @@ bun run dev
 
 Once the TUI opens, run `/agent`, `/home`, or `/operator` to open the Agent operator workspace. That fullscreen workspace is the current front door for setup/config, knowledge status, local memory and skills, read-only work/approval/automation views, and explicit GoodVibes TUI build delegation.
 
+## Isolated Agent Profiles
+
+Use a separate Agent home when you want isolated local state:
+
+```sh
+GOODVIBES_AGENT_HOME=/path/to/agent-home goodvibes-agent status
+```
+
+Use named runtime profiles for repeatable local identities:
+
+```sh
+goodvibes-agent profiles create household --yes
+goodvibes-agent --agent-profile household status
+goodvibes-agent --agent-profile household
+```
+
+Named profiles isolate Agent-local config, sessions, memory, personas, skills, routines, and setup state under a profile-specific home. They do not start or isolate the external daemon by themselves.
+
 ## Local Personas, Routines, And Skills
 
 Personas, routines, and reusable Agent skills are local to GoodVibes Agent. They do not write into default Knowledge/Wiki or HomeGraph.

package/docs/operator-capability-benchmark.md

@@ -43,14 +43,14 @@ Primary sources used for the benchmark:
 | --- | --- | --- |
 | Terminal operator UI | Interactive CLI/TUI, commands, sessions | Near-fork GoodVibes TUI compositor/input/fullscreen foundation |
 | Always-on gateway | Gateway/service owns channels, sessions, tools, events | External GoodVibes daemon, never Agent-owned lifecycle |
-| Channels | WhatsApp, Telegram, Slack, Discord, Signal, iMessage, web chat | GoodVibes daemon channel and companion surfaces with Agent-side policy |
+| Channels | WhatsApp, Telegram, Slack, Discord, Signal, iMessage, web chat | GoodVibes daemon channel and companion surfaces with Agent-side policy and a Channels operator workspace |
 | Knowledge/memory | Durable memory, semantic search, wiki/claim layers | Isolated Agent Knowledge routes plus local memory/skills/personas/routines |
 | Skills/procedural memory | Skills directories, registries, skill lifecycle | Local Agent skills with review/stale/source/provenance fields |
 | Scheduling | Natural-language cron, run/pause/resume/edit/remove, delivery | Guarded automation/schedule routes plus local routines; hidden model scheduling blocked |
 | Tools/MCP | Broad toolsets, MCP, browser, media, terminal, files | GoodVibes SDK tools with Agent policy guards and MCP/provider integrations |
 | Voice/media/canvas/nodes | Voice, TTS, mobile nodes, live canvas, browser automation | GoodVibes media/voice/browser primitives copied in; Agent-first setup still being wired |
 | Build/code work | Direct terminal/file/code tools and subagents | Explicit delegation to GoodVibes TUI; local WRFC/spawn fanout blocked |
-| Profiles | Independent profiles with own config/memory/skills/gateway | Agent surface root, homes, bundles, sessions; named profiles are next |
+| Profiles | Independent profiles with own config/memory/skills/gateway | `GOODVIBES_AGENT_HOME` and named `--agent-profile` homes isolate Agent-local state; daemon remains external |
 | Security | DM pairing, approvals, sandboxing, allowlists | Daemon approvals, auth diagnostics, secret refs, confirmation gates, model-tool policy |
 
 ## Exceed Targets
@@ -66,9 +66,9 @@ GoodVibes Agent should exceed OpenClaw/Hermes by making these properties true fr
 
 ## Current Gaps To Close
 
-- Agent-first channel onboarding workspace for pairing, account visibility, delivery defaults, and channel safety.
+- Per-channel account readiness, delivery defaults, and risk labels in the Channels workspace detail pane.
 - Richer Agent Knowledge ingest/review workspace for URLs, bookmarks, artifacts, issue queues, and consolidation.
-- Named Agent profiles with isolated local registries and command aliases.
+- Profile-aware onboarding summaries and profile export/import shortcuts from the Agent workspace.
 - Voice/media/browser/node setup workspaces.
 - Delegation receipts and artifact review inside the operator workspace.
 - Approval center with route risk labels and saved policy presets.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pellux/goodvibes-agent",
-  "version": "0.1.27",
+  "version": "0.1.29",
   "private": false,
   "description": "Near-fork GoodVibes operator assistant with the GoodVibes TUI shell, renderer, input, fullscreen workspace, and daemon-connected Agent product brain.",
   "type": "module",

package/src/agent/runtime-profile.ts

@@ -0,0 +1,119 @@
+import { existsSync, mkdirSync, readFileSync, readdirSync, rmSync, statSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+
+export interface AgentRuntimeProfileResolution {
+  readonly id: string;
+  readonly homeDirectory: string;
+}
+
+export interface AgentRuntimeProfileInfo extends AgentRuntimeProfileResolution {
+  readonly createdAt: string | null;
+}
+
+export interface AgentRuntimeProfileCommandResult {
+  readonly ok: boolean;
+  readonly kind:
+    | 'agent.profiles.list'
+    | 'agent.profiles.show'
+    | 'agent.profiles.create'
+    | 'agent.profiles.delete'
+    | 'agent.profiles.error';
+  readonly data?: {
+    readonly profiles?: readonly AgentRuntimeProfileInfo[];
+    readonly profile?: AgentRuntimeProfileInfo;
+    readonly nextCommand?: string;
+  };
+  readonly error?: string;
+}
+
+const PROFILE_CREATED_FILE = 'profile.json';
+const PROFILE_ID_PATTERN = /^[a-z0-9](?:[a-z0-9._-]{0,62}[a-z0-9])?$/;
+
+export function normalizeAgentRuntimeProfileId(value: string): string {
+  return value
+    .trim()
+    .toLowerCase()
+    .replace(/[^a-z0-9._-]+/g, '-')
+    .replace(/^[._-]+|[._-]+$/g, '')
+    .replace(/[-_]{2,}/g, '-');
+}
+
+export function assertValidAgentRuntimeProfileId(value: string): string {
+  const raw = value.trim();
+  if (raw.includes('..') || raw.includes('/') || raw.includes('\\')) {
+    throw new Error('Agent profile names cannot contain path traversal sequences.');
+  }
+  const normalized = normalizeAgentRuntimeProfileId(value);
+  if (!PROFILE_ID_PATTERN.test(normalized)) {
+    throw new Error('Agent profile names must normalize to 1-64 lowercase letters, numbers, dots, underscores, or dashes.');
+  }
+  return normalized;
+}
+
+export function getAgentRuntimeProfilesRoot(baseHomeDirectory: string): string {
+  return join(baseHomeDirectory, '.goodvibes', 'agent', 'profile-homes');
+}
+
+export function resolveAgentRuntimeProfileHome(baseHomeDirectory: string, profileName: string): AgentRuntimeProfileResolution {
+  const id = assertValidAgentRuntimeProfileId(profileName);
+  return {
+    id,
+    homeDirectory: join(getAgentRuntimeProfilesRoot(baseHomeDirectory), id),
+  };
+}
+
+function readProfileCreatedAt(homeDirectory: string): string | null {
+  const path = join(homeDirectory, PROFILE_CREATED_FILE);
+  if (!existsSync(path)) return null;
+  try {
+    const raw = JSON.parse(readFileSync(path, 'utf-8'));
+    if (raw && typeof raw === 'object' && typeof raw.createdAt === 'string') return raw.createdAt;
+  } catch {
+    return null;
+  }
+  return null;
+}
+
+function buildProfileInfo(baseHomeDirectory: string, id: string): AgentRuntimeProfileInfo {
+  const { homeDirectory } = resolveAgentRuntimeProfileHome(baseHomeDirectory, id);
+  return {
+    id,
+    homeDirectory,
+    createdAt: readProfileCreatedAt(homeDirectory),
+  };
+}
+
+export function listAgentRuntimeProfiles(baseHomeDirectory: string): readonly AgentRuntimeProfileInfo[] {
+  const root = getAgentRuntimeProfilesRoot(baseHomeDirectory);
+  if (!existsSync(root)) return [];
+  return readdirSync(root)
+    .filter((entry) => PROFILE_ID_PATTERN.test(entry) && !entry.includes('..'))
+    .filter((entry) => {
+      try {
+        return statSync(join(root, entry)).isDirectory();
+      } catch {
+        return false;
+      }
+    })
+    .sort((left, right) => left.localeCompare(right))
+    .map((entry) => buildProfileInfo(baseHomeDirectory, entry));
+}
+
+export function createAgentRuntimeProfile(baseHomeDirectory: string, profileName: string): AgentRuntimeProfileInfo {
+  const resolution = resolveAgentRuntimeProfileHome(baseHomeDirectory, profileName);
+  mkdirSync(resolution.homeDirectory, { recursive: true });
+  const createdAt = new Date().toISOString();
+  writeFileSync(
+    join(resolution.homeDirectory, PROFILE_CREATED_FILE),
+    `${JSON.stringify({ id: resolution.id, createdAt }, null, 2)}\n`,
+    'utf-8',
+  );
+  return { ...resolution, createdAt };
+}
+
+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 });
+  return true;
+}

package/src/cli/completion.ts

@@ -11,7 +11,14 @@ const COMMANDS = [
   'status',
   'models',
   'providers',
+  'profiles',
   'auth',
+  'compat',
+  'capabilities',
+  'knowledge',
+  'ask',
+  'search',
+  'delegate',
   'subscription',
   'secrets',
   'sessions',
@@ -34,6 +41,7 @@ const OPTIONS = [
   '--version',
   '--model',
   '--provider',
+  '--agent-profile',
   '--cd',
   '--working-dir',
   '--daemon-home',

package/src/cli/entrypoint.ts

@@ -23,6 +23,7 @@ import {
 } from './index.ts';
 import { buildCliServicePosture } from './service-posture.ts';
 import { GOODVIBES_AGENT_SURFACE_ROOT } from '../config/surface.ts';
+import { resolveAgentRuntimeProfileHome } from '../agent/runtime-profile.ts';
 
 type ShellEntrypointOwnership = {
   readonly workingDirectory: string;
@@ -41,10 +42,17 @@ export type PreparedShellCliRuntime = {
   readonly bootstrapHomeDirectory: string;
 };
 
-function resolveShellEntrypointOwnership(roots: ShellEntrypointRoots, workingDirOverride?: string): ShellEntrypointOwnership {
+function resolveShellEntrypointOwnership(
+  roots: ShellEntrypointRoots,
+  workingDirOverride?: string,
+  agentProfile?: string,
+): ShellEntrypointOwnership {
+  const homeDirectory = agentProfile
+    ? resolveAgentRuntimeProfileHome(roots.homeDirectory, agentProfile).homeDirectory
+    : roots.homeDirectory;
   return {
     workingDirectory: workingDirOverride ?? roots.defaultWorkingDirectory,
-    homeDirectory: roots.homeDirectory,
+    homeDirectory,
   };
 }
 
@@ -86,10 +94,21 @@ export async function prepareShellCliRuntime(
     process.exit(2);
   }
 
+  let ownership: ShellEntrypointOwnership;
+  try {
+    ownership = resolveShellEntrypointOwnership(
+      roots,
+      cli.flags.workingDir ?? (cli.command === 'tui' ? cli.commandArgs[0] : undefined),
+      cli.command === 'profiles' ? undefined : cli.flags.agentProfile,
+    );
+  } catch (error) {
+    console.error(error instanceof Error ? error.message : String(error));
+    process.exit(2);
+  }
   const {
     workingDirectory: bootstrapWorkingDir,
     homeDirectory: bootstrapHomeDirectory,
-  } = resolveShellEntrypointOwnership(roots, cli.flags.workingDir ?? (cli.command === 'tui' ? cli.commandArgs[0] : undefined));
+  } = ownership;
   configureActivityLogger(join(bootstrapWorkingDir, '.goodvibes', 'logs'));
   const configManager = new ConfigManager({
     workingDir: bootstrapWorkingDir,

package/src/cli/help.ts

@@ -38,6 +38,7 @@ export function renderGoodVibesHelp(binary = 'goodvibes-agent'): string {
     '  onboarding [status]        Open Agent onboarding, or print onboarding status',
     '  models [provider]          List/use/pin selectable models and recent model history',
     '  providers                  List/inspect/use provider config/auth posture',
+    '  profiles                   Manage isolated Agent runtime profile homes',
     '  auth                       Inspect and manage local users, sessions, and bootstrap auth',
     '  compat                     Inspect Agent SDK pin, daemon version, and Agent knowledge route readiness',
     '  capabilities               Show OpenClaw/Hermes capability parity and Agent readiness',
@@ -62,6 +63,7 @@ export function renderGoodVibesHelp(binary = 'goodvibes-agent'): string {
     'Options:',
     '  -m, --model <registryKey>       Override model. provider:model infers --provider',
     '      --provider <id>            Override provider',
+    '      --agent-profile <name>     Use an isolated Agent runtime profile home',
     '  -C, --cd <dir>                 Set working directory for this launch',
     '      --working-dir <dir>        Alias for --cd',
     '      --daemon-home <dir>        Override daemon home for daemon-backed commands',
@@ -94,6 +96,8 @@ export function renderGoodVibesHelp(binary = 'goodvibes-agent'): string {
     `  ${binary} models current`,
     `  ${binary} models use openai:gpt-5.2`,
     `  ${binary} providers inspect openai`,
+    `  ${binary} profiles create household --yes`,
+    `  ${binary} --agent-profile household`,
     `  ${binary} compat`,
     `  ${binary} capabilities`,
     `  ${binary} knowledge status`,
@@ -149,6 +153,11 @@ const COMMAND_HELP: Record<string, CommandHelp> = {
     summary: 'Inspect and change provider setup, auth posture, model counts, and setup class.',
     examples: ['providers', 'providers inspect openai-subscriber', 'providers use openai openai:gpt-5.4'],
   },
+  profiles: {
+    usage: ['profiles list', 'profiles show <name>', 'profiles create <name> --yes', 'profiles delete <name> --yes', '--agent-profile <name>'],
+    summary: 'Create and inspect isolated Agent runtime profile homes. A profile changes Agent-local config, sessions, memory, personas, skills, routines, and setup paths without changing the externally owned daemon.',
+    examples: ['profiles create household --yes', 'profiles list', '--agent-profile household status', '--agent-profile household'],
+  },
   models: {
     usage: ['models [provider]', 'models current', 'models use <registryKey>', 'models pin <registryKey>', 'models recent'],
     summary: 'List, inspect, select, pin, and review model choices.',
@@ -280,6 +289,7 @@ const HELP_ALIASES: Record<string, string> = {
   setup: 'onboarding',
   provider: 'providers',
   model: 'models',
+  profile: 'profiles',
   subscriptions: 'subscription',
   secret: 'secrets',
   session: 'sessions',

package/src/cli/management.ts

@@ -34,6 +34,7 @@ import { buildListenerTestResult, formatListenerTestResult, handleSurfacesComman
 import { buildControlPlaneStatusResult, formatControlPlaneStatus, handleSecrets, handleSessions, handleTasks, renderPairing, renderRemote, renderSubscriptions, renderWeb } from './management-commands.ts';
 import { handleAgentKnowledgeCommand, handleAgentKnowledgeShortcutCommand, handleCompatCommand, handleDelegateCommand } from './agent-knowledge-command.ts';
 import { handleCapabilitiesCommand } from './capabilities-command.ts';
+import { handleProfilesCommand } from './profiles-command.ts';
 import { GOODVIBES_AGENT_SURFACE_ROOT } from '../config/surface.ts';
 
 export interface CliCommandRuntime {
@@ -704,6 +705,11 @@ export async function handleGoodVibesCliCommand(runtime: CliCommandRuntime): Pro
         console.log(result.output);
         return { handled: true, exitCode: result.exitCode };
       }
+      case 'profiles': {
+        const result = await handleProfilesCommand(runtime);
+        console.log(result.output);
+        return { handled: true, exitCode: result.exitCode };
+      }
       case 'knowledge': {
         const result = await handleAgentKnowledgeCommand(runtime);
         console.log(result.output);

package/src/cli/parser.ts

@@ -25,6 +25,8 @@ const COMMAND_ALIASES: Readonly<Record<string, GoodVibesCliCommand>> = {
   model: 'models',
   providers: 'providers',
   provider: 'providers',
+  profiles: 'profiles',
+  profile: 'profiles',
   auth: 'auth',
   compat: 'compat',
   compatibility: 'compat',
@@ -73,6 +75,7 @@ function createDefaultFlags(): GoodVibesCliFlags {
   return {
     provider: undefined,
     model: undefined,
+    agentProfile: undefined,
     daemonHome: undefined,
     workingDir: undefined,
     help: false,
@@ -279,6 +282,12 @@ export function parseGoodVibesCli(
       }
       continue;
     }
+    if (name === '--agent-profile') {
+      const consumed = getValue(argv, index, inlineValue, name, errors);
+      index = consumed.nextIndex;
+      if (consumed.value !== undefined) flags = withFlag(flags, 'agentProfile', consumed.value);
+      continue;
+    }
     if (name === '--daemon-home') {
       const consumed = getValue(argv, index, inlineValue, name, errors);
       index = consumed.nextIndex;

package/src/cli/profiles-command.ts

@@ -0,0 +1,208 @@
+import {
+  createAgentRuntimeProfile,
+  deleteAgentRuntimeProfile,
+  listAgentRuntimeProfiles,
+  resolveAgentRuntimeProfileHome,
+  type AgentRuntimeProfileCommandResult,
+  type AgentRuntimeProfileInfo,
+} from '../agent/runtime-profile.ts';
+import type { CliCommandOutput, GoodVibesCliParseResult } from './types.ts';
+
+interface ProfilesCommandRuntime {
+  readonly cli: GoodVibesCliParseResult;
+  readonly homeDirectory: string;
+}
+
+function hasYes(args: readonly string[]): boolean {
+  return args.includes('--yes');
+}
+
+function commandValues(args: readonly string[]): readonly string[] {
+  const values: string[] = [];
+  for (let index = 0; index < args.length; index += 1) {
+    const token = args[index]!;
+    if (!token.startsWith('--')) values.push(token);
+  }
+  return values;
+}
+
+function profileLine(profile: AgentRuntimeProfileInfo): string {
+  const created = profile.createdAt ? ` created=${profile.createdAt}` : '';
+  return `  ${profile.id}  home=${profile.homeDirectory}${created}`;
+}
+
+function renderProfilesResult(result: AgentRuntimeProfileCommandResult): string {
+  if (!result.ok) return result.error ?? 'Agent profile command failed.';
+  if (result.kind === 'agent.profiles.list') {
+    const profiles = result.data?.profiles ?? [];
+    if (profiles.length === 0) return 'No Agent runtime profiles. Use: goodvibes-agent profiles create <name> --yes';
+    return [
+      `Agent runtime profiles (${profiles.length})`,
+      ...profiles.map(profileLine),
+    ].join('\n');
+  }
+  const profile = result.data?.profile;
+  if (result.kind === 'agent.profiles.create' && profile) {
+    return [
+      `Agent runtime profile created: ${profile.id}`,
+      `  home: ${profile.homeDirectory}`,
+      `  use: ${result.data?.nextCommand ?? `goodvibes-agent --agent-profile ${profile.id}`}`,
+    ].join('\n');
+  }
+  if (result.kind === 'agent.profiles.delete' && profile) {
+    return `Agent runtime profile deleted: ${profile.id}`;
+  }
+  return 'Agent profile command completed.';
+}
+
+function renderProfilesOutput(result: AgentRuntimeProfileCommandResult, format: string): string {
+  if (format === 'json') return JSON.stringify(result, null, 2);
+  return renderProfilesResult(result);
+}
+
+export async function handleProfilesCommand(runtime: ProfilesCommandRuntime): Promise<CliCommandOutput> {
+  const [sub = 'list', ...rawRest] = runtime.cli.commandArgs;
+  const values = commandValues(rawRest);
+
+  try {
+    if (sub === 'list' || sub === 'ls') {
+      const result: AgentRuntimeProfileCommandResult = {
+        ok: true,
+        kind: 'agent.profiles.list',
+        data: { profiles: listAgentRuntimeProfiles(runtime.homeDirectory) },
+      };
+      return {
+        output: renderProfilesOutput(result, runtime.cli.flags.outputFormat),
+        exitCode: 0,
+      };
+    }
+
+    if (sub === 'show' || sub === 'path' || sub === 'home') {
+      const name = values[0];
+      if (!name) {
+        const result: AgentRuntimeProfileCommandResult = {
+          ok: false,
+          kind: 'agent.profiles.error',
+          error: 'Usage: goodvibes-agent profiles show <name>',
+        };
+        return {
+          output: renderProfilesOutput(result, runtime.cli.flags.outputFormat),
+          exitCode: 2,
+        };
+      }
+      const profile = resolveAgentRuntimeProfileHome(runtime.homeDirectory, name);
+      const result: AgentRuntimeProfileCommandResult = {
+        ok: true,
+        kind: 'agent.profiles.show',
+        data: { profile: { ...profile, createdAt: null } },
+      };
+      const text = [`Agent runtime profile: ${profile.id}`, `  home: ${profile.homeDirectory}`, `  use: goodvibes-agent --agent-profile ${profile.id}`].join('\n');
+      return {
+        output: runtime.cli.flags.outputFormat === 'json' ? JSON.stringify(result, null, 2) : text,
+        exitCode: 0,
+      };
+    }
+
+    if (sub === 'create') {
+      const name = values[0];
+      if (!name) {
+        const result: AgentRuntimeProfileCommandResult = {
+          ok: false,
+          kind: 'agent.profiles.error',
+          error: 'Usage: goodvibes-agent profiles create <name> --yes',
+        };
+        return {
+          output: renderProfilesOutput(result, runtime.cli.flags.outputFormat),
+          exitCode: 2,
+        };
+      }
+      if (!hasYes(rawRest)) {
+        const result: AgentRuntimeProfileCommandResult = {
+          ok: false,
+          kind: 'agent.profiles.error',
+          error: `Refusing to create Agent runtime profile ${name} without --yes.`,
+        };
+        return {
+          output: renderProfilesOutput(result, runtime.cli.flags.outputFormat),
+          exitCode: 2,
+        };
+      }
+      const profile = createAgentRuntimeProfile(runtime.homeDirectory, name);
+      const result: AgentRuntimeProfileCommandResult = {
+        ok: true,
+        kind: 'agent.profiles.create',
+        data: {
+          profile,
+          nextCommand: `goodvibes-agent --agent-profile ${profile.id}`,
+        },
+      };
+      return {
+        output: renderProfilesOutput(result, runtime.cli.flags.outputFormat),
+        exitCode: 0,
+      };
+    }
+
+    if (sub === 'delete' || sub === 'remove') {
+      const name = values[0];
+      if (!name) {
+        const result: AgentRuntimeProfileCommandResult = {
+          ok: false,
+          kind: 'agent.profiles.error',
+          error: 'Usage: goodvibes-agent profiles delete <name> --yes',
+        };
+        return {
+          output: renderProfilesOutput(result, runtime.cli.flags.outputFormat),
+          exitCode: 2,
+        };
+      }
+      if (!hasYes(rawRest)) {
+        const result: AgentRuntimeProfileCommandResult = {
+          ok: false,
+          kind: 'agent.profiles.error',
+          error: `Refusing to delete Agent runtime profile ${name} without --yes.`,
+        };
+        return {
+          output: renderProfilesOutput(result, runtime.cli.flags.outputFormat),
+          exitCode: 2,
+        };
+      }
+      const resolution = resolveAgentRuntimeProfileHome(runtime.homeDirectory, name);
+      const deleted = deleteAgentRuntimeProfile(runtime.homeDirectory, name);
+      const result: AgentRuntimeProfileCommandResult = deleted
+        ? {
+          ok: true,
+          kind: 'agent.profiles.delete',
+          data: { profile: { ...resolution, createdAt: null } },
+        }
+        : {
+          ok: false,
+          kind: 'agent.profiles.error',
+          error: `Agent runtime profile not found: ${resolution.id}`,
+      };
+      return {
+        output: renderProfilesOutput(result, runtime.cli.flags.outputFormat),
+        exitCode: deleted ? 0 : 1,
+      };
+    }
+
+    const result: AgentRuntimeProfileCommandResult = {
+      ok: false,
+      kind: 'agent.profiles.error',
+      error: 'Usage: goodvibes-agent profiles [list|show <name>|create <name> --yes|delete <name> --yes]',
+    };
+    return {
+      output: renderProfilesOutput(result, runtime.cli.flags.outputFormat),
+      exitCode: 2,
+    };
+  } catch (error) {
+    const result: AgentRuntimeProfileCommandResult = {
+      ok: false,
+      kind: 'agent.profiles.error',
+      error: error instanceof Error ? error.message : String(error),
+    };
+    return {
+      output: renderProfilesOutput(result, runtime.cli.flags.outputFormat),
+      exitCode: 2,
+    };
+  }
+}

package/src/cli/types.ts

@@ -9,6 +9,7 @@ export type GoodVibesCliCommand =
   | 'onboarding'
   | 'models'
   | 'providers'
+  | 'profiles'
   | 'auth'
   | 'compat'
   | 'capabilities'
@@ -42,6 +43,7 @@ export interface CliCommandOutput {
 export interface GoodVibesCliFlags {
   readonly provider: string | undefined;
   readonly model: string | undefined;
+  readonly agentProfile: string | undefined;
   readonly daemonHome: string | undefined;
   readonly workingDir: string | undefined;
   readonly help: boolean;

package/src/input/agent-workspace.ts

@@ -192,6 +192,19 @@ export const AGENT_WORKSPACE_CATEGORIES: readonly AgentWorkspaceCategory[] = [
       { id: 'auth', label: 'Auth review', detail: 'Review authentication posture without printing token values.', command: '/auth review', kind: 'command', safety: 'read-only' },
     ],
   },
+  {
+    id: 'channels',
+    group: 'SETUP',
+    label: 'Channels',
+    summary: 'Companion pairing, channel posture, and delivery safety.',
+    detail: 'Agent uses externally owned daemon channel surfaces. Pairing, account inspection, and readiness checks are visible here; inbound delivery and public channel exposure stay policy-gated.',
+    actions: [
+      { id: 'pair', label: 'Pair companion', detail: 'Open the TUI-derived QR pairing surface for companion app setup.', command: '/pair', kind: 'command', safety: 'safe' },
+      { id: 'communication', label: 'Communication routes', detail: 'Inspect structured communication routes and recent activity.', command: '/communication', kind: 'command', safety: 'read-only' },
+      { id: 'setup-review', label: 'Channel setup review', detail: 'Review setup posture without starting listeners or mutating daemon surface state.', command: '/setup review', kind: 'command', safety: 'read-only' },
+      { id: 'channel-safety', label: 'Delivery safety', detail: 'External messages, channel DMs, and public delivery targets require explicit user action and daemon-side policy. Agent will not silently send or expose channels from this workspace.', kind: 'guidance', safety: 'blocked' },
+    ],
+  },
   {
     id: 'knowledge',
     group: 'KNOW',

package/src/main.ts

@@ -70,7 +70,7 @@ async function main() {
   const stdin = process.stdin;
   const { cli, configManager, bootstrapWorkingDir, bootstrapHomeDirectory } = await prepareShellCliRuntime(process.argv.slice(2), {
     defaultWorkingDirectory: process.env['GOODVIBES_WORKING_DIR'] ?? process.cwd(),
-    homeDirectory: homedir(),
+    homeDirectory: process.env['GOODVIBES_AGENT_HOME'] ?? homedir(),
   }, 'goodvibes-agent');
 
   const ctx: BootstrapContext = await bootstrapRuntime(stdout, {
@@ -267,7 +267,7 @@ async function main() {
 
   const submitInput = (text: string, content?: ContentPart[], options: { readonly spokenOutput?: boolean } = {}) => {
     input.clearModalStack();
-    scrollLocked = true; // Re-lock on any user input
+    scrollLocked = true; // Re-lock on user input
     const AT_MODEL_RE = /@model:([^\s]+)/g;
     let processedText = text;
     let atModelMatch: RegExpExecArray | null;

package/src/operator/capability-benchmark.ts

@@ -69,11 +69,11 @@ export const OPERATOR_CAPABILITY_BENCHMARKS: readonly OperatorCapabilityBenchmar
     posture: 'configurable',
     competitors: ['openclaw', 'hermes'],
     competitorBaseline: 'Messaging gateway for WhatsApp, Telegram, Slack, Discord, Signal, iMessage, web chat, and related platforms.',
-    goodvibesAgent: 'Uses GoodVibes daemon channel, companion, pairing, QR, and session surfaces while keeping side effects behind explicit user action.',
-    configure: ['goodvibes-agent pair', 'goodvibes-agent qrcode', 'goodvibes-agent surfaces check'],
-    use: ['/channels', '/communication', '/pair'],
-    exceedsBy: ['Agent-owned safety policy over shared channel routes', 'read-only inspection by default', 'explicit approval path for external side effects'],
-    next: ['Add Agent-first channel onboarding workspace that exposes connected accounts, delivery defaults, and pairing state without daemon ownership.'],
+    goodvibesAgent: 'Uses GoodVibes daemon channel, companion, pairing, QR, communication, and session surfaces while keeping side effects behind explicit user action. The Agent workspace exposes channel setup and safety as a first-class operator area.',
+    configure: ['goodvibes-agent pair', 'goodvibes-agent qrcode', 'goodvibes-agent surfaces check', '/agent → Channels'],
+    use: ['/agent → Channels', '/communication', '/pair'],
+    exceedsBy: ['Agent-owned safety policy over shared channel routes', 'read-only inspection by default', 'explicit approval path for external side effects', 'channel setup discoverable from the fullscreen operator workspace'],
+    next: ['Add per-channel account readiness, delivery defaults, and risk labels directly in the Channels workspace detail pane.'],
   },
   {
     id: 'isolated-knowledge-wiki',
@@ -150,14 +150,14 @@ export const OPERATOR_CAPABILITY_BENCHMARKS: readonly OperatorCapabilityBenchmar
   {
     id: 'profiles-isolation',
     title: 'Profiles And Isolated Operator State',
-    posture: 'configurable',
+    posture: 'ready',
     competitors: ['hermes'],
     competitorBaseline: 'Profiles run independent agents with isolated configs, sessions, skills, memory, cron jobs, and gateway state.',
-    goodvibesAgent: 'Uses Agent surface root, explicit home/working-dir flags, local registries, sessions, and bundle export/import; daemon remains shared/external by design.',
-    configure: ['GOODVIBES_AGENT_HOME=<path> goodvibes-agent status', 'goodvibes-agent bundle export goodvibes-agent-bundle.json'],
-    use: ['goodvibes-agent --daemon-home <path> status', 'goodvibes-agent sessions list'],
-    exceedsBy: ['Typed support bundles', 'explicit daemon boundary', 'no accidental cross-product knowledge fallback'],
-    next: ['Add named Agent profiles with command aliases, isolated local registry paths, and profile-aware onboarding.'],
+    goodvibesAgent: 'Supports GOODVIBES_AGENT_HOME and named --agent-profile homes for isolated Agent-local config, sessions, memory, personas, skills, routines, setup, and bundles; daemon remains shared/external by design.',
+    configure: ['GOODVIBES_AGENT_HOME=<path> goodvibes-agent status', 'goodvibes-agent profiles create household --yes', 'goodvibes-agent bundle export goodvibes-agent-bundle.json'],
+    use: ['goodvibes-agent --agent-profile household', 'goodvibes-agent --agent-profile household status', 'goodvibes-agent sessions list'],
+    exceedsBy: ['Typed support bundles', 'explicit daemon boundary', 'no accidental cross-product knowledge fallback', 'profile isolation without hidden daemon lifecycle ownership'],
+    next: ['Add profile-aware onboarding summaries and profile export/import shortcuts from the Agent workspace.'],
   },
   {
     id: 'security-approvals',

package/src/renderer/agent-workspace.ts

@@ -88,6 +88,13 @@ function snapshotLines(category: AgentWorkspaceCategory, snapshot: AgentWorkspac
       { text: `Workspace: ${snapshot.workingDirectory}`, fg: PALETTE.muted },
       { text: `Home: ${snapshot.homeDirectory}`, fg: PALETTE.muted },
     );
+  } else if (category.id === 'channels') {
+    base.push(
+      { text: `External daemon: ${snapshot.daemonBaseUrl}`, fg: PALETTE.info },
+      { text: 'Pairing: use /pair or /qrcode for companion setup.', fg: PALETTE.info },
+      { text: 'Channel posture: inspect via /communication and /setup review.', fg: PALETTE.muted },
+      { text: 'Safety: external delivery, unknown senders, and public exposure require explicit policy and user action.', fg: PALETTE.warn },
+    );
   } else if (category.id === 'knowledge') {
     base.push(
       { text: `Route family: ${snapshot.knowledgeRoute}/{status,ask,search}`, fg: PALETTE.info },

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.27';
+let _version = '0.1.29';
 let _sdkVersion = '0.33.35';
 try {
   const pkg = JSON.parse(readFileSync(join(import.meta.dir, '..', 'package.json'), 'utf-8')) as {