@pellux/goodvibes-agent 0.1.26 → 0.1.28

package/CHANGELOG.md

@@ -2,6 +2,15 @@
 
 All notable changes to GoodVibes Agent will be recorded here.
 
+## 0.1.28 - 2026-05-31
+
+- 77a9dc4 Add isolated Agent runtime profiles
+
+## 0.1.27 - 2026-05-31
+
+- b5be172 Add capabilities CLI handler
+- cafe1fb Add Agent capability benchmark surface
+
 ## 0.1.26 - 2026-05-31
 
 - dfb6147 Harden Agent read tool policy

package/README.md

@@ -15,6 +15,7 @@ Install the public alpha package with Bun:
 bun add -g @pellux/goodvibes-agent
 goodvibes-agent --help
 goodvibes-agent status
+goodvibes-agent capabilities
 ```
 
 If Bun reports untrusted lifecycle dependencies, trust only the package and dependencies required by this package:
@@ -43,6 +44,18 @@ bun run publish:check
 
 Inside the Agent TUI, use `/agent`, `/home`, or `/operator` to open the operator workspace. It is the Agent-first fullscreen surface for setup, status, knowledge, local memory/skills, work-plan/approval review, automation observability, and explicit build delegation to GoodVibes TUI.
 
+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
@@ -81,6 +94,7 @@ GoodVibes TUI owns coding execution: file edits, git/worktree workflows, coding
 Package-facing docs are intentionally narrow during the near-fork baseline:
 
 - [Getting Started](docs/getting-started.md)
+- [Operator Capability Benchmark](docs/operator-capability-benchmark.md)
 - [Deployment And Services](docs/deployment-and-services.md)
 - [Release And Publishing](docs/release-and-publishing.md)
 

package/docs/README.md

@@ -7,6 +7,7 @@ GoodVibes Agent is a near-fork of the GoodVibes terminal foundation with a diffe
 Current package docs:
 
 - [Getting Started](getting-started.md)
+- [Operator Capability Benchmark](operator-capability-benchmark.md)
 - [Deployment And Services](deployment-and-services.md)
 - [Release And Publishing](release-and-publishing.md)
 
@@ -18,6 +19,8 @@ Important baseline constraints:
 - Agent connects to an externally managed daemon.
 - 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

@@ -0,0 +1,75 @@
+# Operator Capability Benchmark
+
+GoodVibes Agent is built to compete directly with OpenClaw and Hermes Agent in the personal-operator assistant space, while keeping the GoodVibes product boundary explicit:
+
+- Agent uses the GoodVibes TUI shell, renderer, input, fullscreen workspace, command registry, and release bones.
+- Agent connects to an externally managed GoodVibes daemon.
+- Agent Knowledge/Wiki uses only `/api/goodvibes-agent/knowledge/*`.
+- Agent never falls back to default Knowledge/Wiki, HomeGraph, or Home Assistant routes.
+- Agent keeps ordinary work serial in the main conversation.
+- Agent delegates explicit build/fix/review work to GoodVibes TUI; WRFC is never default.
+
+Use the live benchmark from the package:
+
+```sh
+goodvibes-agent capabilities
+goodvibes-agent capabilities --json
+goodvibes-agent capabilities hermes
+```
+
+Inside the TUI:
+
+```text
+/capabilities
+/capabilities openclaw
+/capabilities knowledge
+```
+
+## Research Baseline
+
+Primary sources used for the benchmark:
+
+- OpenClaw README: https://github.com/openclaw/openclaw/blob/main/README.md
+- OpenClaw FAQ: https://docs.openclaw.ai/help/faq
+- OpenClaw Memory: https://docs.openclaw.ai/concepts/memory
+- Hermes README: https://github.com/NousResearch/hermes-agent
+- Hermes Tools: https://hermes-agent.nousresearch.com/docs/user-guide/features/tools/
+- Hermes Cron: https://hermes-agent.nousresearch.com/docs/user-guide/features/cron/
+- Hermes Profiles: https://hermes-agent.nousresearch.com/docs/user-guide/profiles/
+
+## Capability Targets
+
+| Area | OpenClaw/Hermes Baseline | GoodVibes Agent Position |
+| --- | --- | --- |
+| 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 |
+| 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 | `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
+
+GoodVibes Agent should exceed OpenClaw/Hermes by making these properties true from day one:
+
+- Capability surfaces are discoverable through `goodvibes-agent capabilities`, `/capabilities`, onboarding, and the operator workspace.
+- Agent Knowledge isolation is a release gate, not a convention.
+- Model-visible tools are policy-gated for serial, non-secret, non-destructive use.
+- Personal assistant state is Agent-local unless an explicit Agent Knowledge ingest route is used.
+- Build work is delegated to the product that owns coding execution instead of turning the personal operator into a second coding TUI.
+- Release gates prove package installability, Bun/TypeScript-only source, external-daemon posture, no authored JavaScript, no explicit `any`, and no forbidden default wiki/HomeGraph package-facing docs.
+
+## Current Gaps To Close
+
+- Agent-first channel onboarding workspace for pairing, account visibility, delivery defaults, and channel safety.
+- Richer Agent Knowledge ingest/review workspace for URLs, bookmarks, artifacts, issue queues, and consolidation.
+- 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.
+- Intent-gated tool exposure so the model sees fewer irrelevant tools per turn while retaining broad capability coverage.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pellux/goodvibes-agent",
-  "version": "0.1.26",
+  "version": "0.1.28",
   "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",
@@ -33,6 +33,7 @@
     "CHANGELOG.md",
     "docs/README.md",
     "docs/getting-started.md",
+    "docs/operator-capability-benchmark.md",
     "docs/deployment-and-services.md",
     "docs/release-and-publishing.md"
   ],

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/capabilities-command.ts

@@ -0,0 +1,28 @@
+import type { CliCommandOutput } from './types.ts';
+import type { CliCommandRuntime } from './management.ts';
+import {
+  buildOperatorCapabilityBenchmarkReport,
+  filterOperatorCapabilities,
+  renderOperatorCapabilityBenchmark,
+} from '../operator/capability-benchmark.ts';
+
+function readCapabilityQuery(args: readonly string[]): string | undefined {
+  const values = args.filter((arg) => !arg.startsWith('--'));
+  return values.length > 0 ? values.join(' ') : undefined;
+}
+
+export async function handleCapabilitiesCommand(runtime: CliCommandRuntime): Promise<CliCommandOutput> {
+  const query = readCapabilityQuery(runtime.cli.commandArgs);
+  const report = buildOperatorCapabilityBenchmarkReport();
+  const capabilities = filterOperatorCapabilities(report.capabilities, query);
+  if (runtime.cli.flags.outputFormat === 'json') {
+    return {
+      output: JSON.stringify({ ...report, capabilities }, null, 2),
+      exitCode: 0,
+    };
+  }
+  return {
+    output: renderOperatorCapabilityBenchmark(capabilities),
+    exitCode: 0,
+  };
+}

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,8 +38,10 @@ 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',
     '  knowledge                  Use isolated Agent Knowledge/Wiki routes',
     '  ask|search                 Shortcuts for isolated Agent Knowledge ask/search',
     '  delegate                   Explicitly delegate build/fix/review work to GoodVibes TUI',
@@ -61,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',
@@ -93,7 +96,10 @@ 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`,
     `  ${binary} knowledge ask "What is GoodVibes Agent?"`,
     `  ${binary} ask "What is GoodVibes Agent?"`,
@@ -147,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.',
@@ -162,6 +173,11 @@ const COMMAND_HELP: Record<string, CommandHelp> = {
     summary: 'Inspect package SDK pin, live daemon version, and Agent-specific knowledge route readiness.',
     examples: ['compat', 'compat --json'],
   },
+  capabilities: {
+    usage: ['capabilities [openclaw|hermes|query]', 'capabilities --json'],
+    summary: 'Show the OpenClaw/Hermes capability benchmark, Agent readiness, configuration commands, usage paths, and next product gaps.',
+    examples: ['capabilities', 'capabilities hermes', 'capabilities knowledge --json'],
+  },
   knowledge: {
     usage: [
       'knowledge status',
@@ -273,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

@@ -33,6 +33,8 @@ import { handleBundleCommand } from './bundle-command.ts';
 import { buildListenerTestResult, formatListenerTestResult, handleSurfacesCommand } from './surface-command.ts';
 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 {
@@ -698,6 +700,16 @@ export async function handleGoodVibesCliCommand(runtime: CliCommandRuntime): Pro
         console.log(result.output);
         return { handled: true, exitCode: result.exitCode };
       }
+      case 'capabilities': {
+        const result = await handleCapabilitiesCommand(runtime);
+        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/package-verification.ts

@@ -41,6 +41,7 @@ const REQUIRED_TARBALL_PATHS = [
   '.goodvibes/GOODVIBES.md',
   'docs/README.md',
   'docs/getting-started.md',
+  'docs/operator-capability-benchmark.md',
   'docs/deployment-and-services.md',
   'docs/release-and-publishing.md',
 ] as const;

package/src/cli/parser.ts

@@ -25,9 +25,15 @@ const COMMAND_ALIASES: Readonly<Record<string, GoodVibesCliCommand>> = {
   model: 'models',
   providers: 'providers',
   provider: 'providers',
+  profiles: 'profiles',
+  profile: 'profiles',
   auth: 'auth',
   compat: 'compat',
   compatibility: 'compat',
+  capabilities: 'capabilities',
+  capability: 'capabilities',
+  caps: 'capabilities',
+  benchmark: 'capabilities',
   knowledge: 'knowledge',
   know: 'knowledge',
   kb: 'knowledge',
@@ -69,6 +75,7 @@ function createDefaultFlags(): GoodVibesCliFlags {
   return {
     provider: undefined,
     model: undefined,
+    agentProfile: undefined,
     daemonHome: undefined,
     workingDir: undefined,
     help: false,
@@ -275,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,8 +9,10 @@ export type GoodVibesCliCommand =
   | 'onboarding'
   | 'models'
   | 'providers'
+  | 'profiles'
   | 'auth'
   | 'compat'
+  | 'capabilities'
   | 'knowledge'
   | 'ask'
   | 'search'
@@ -41,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/commands/capabilities-runtime.ts

@@ -0,0 +1,20 @@
+import type { CommandRegistry } from '../command-registry.ts';
+import {
+  filterOperatorCapabilities,
+  renderOperatorCapabilityBenchmark,
+  OPERATOR_CAPABILITY_BENCHMARKS,
+} from '../../operator/capability-benchmark.ts';
+
+export function registerCapabilitiesRuntimeCommands(registry: CommandRegistry): void {
+  registry.register({
+    name: 'capabilities',
+    aliases: ['caps', 'benchmark'],
+    description: 'Show the OpenClaw/Hermes capability benchmark and Agent readiness',
+    usage: '[openclaw|hermes|query]',
+    handler(args, ctx) {
+      const query = args.join(' ').trim() || undefined;
+      const capabilities = filterOperatorCapabilities(OPERATOR_CAPABILITY_BENCHMARKS, query);
+      ctx.print(renderOperatorCapabilityBenchmark(capabilities));
+    },
+  });
+}

package/src/input/commands.ts

@@ -58,6 +58,7 @@ import { registerDelegationRuntimeCommands } from './commands/delegation-runtime
 import { registerPersonasRuntimeCommands } from './commands/personas-runtime.ts';
 import { registerAgentSkillsRuntimeCommands } from './commands/agent-skills-runtime.ts';
 import { registerRoutinesRuntimeCommands } from './commands/routines-runtime.ts';
+import { registerCapabilitiesRuntimeCommands } from './commands/capabilities-runtime.ts';
 
 /**
  * registerBuiltinCommands - Register all built-in slash commands into the registry.
@@ -66,6 +67,7 @@ import { registerRoutinesRuntimeCommands } from './commands/routines-runtime.ts'
 export function registerBuiltinCommands(registry: CommandRegistry): void {
   registerShellCoreCommands(registry);
   registerAgentWorkspaceRuntimeCommands(registry);
+  registerCapabilitiesRuntimeCommands(registry);
   registerPersonasRuntimeCommands(registry);
   registerAgentSkillsRuntimeCommands(registry);
   registerRoutinesRuntimeCommands(registry);

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

@@ -0,0 +1,225 @@
+export type CompetitorProduct = 'openclaw' | 'hermes';
+
+export type CapabilityPosture =
+  | 'ready'
+  | 'configurable'
+  | 'external-daemon'
+  | 'explicit-delegation'
+  | 'guarded'
+  | 'in-progress';
+
+export interface OperatorCapabilityBenchmark {
+  readonly id: string;
+  readonly title: string;
+  readonly posture: CapabilityPosture;
+  readonly competitors: readonly CompetitorProduct[];
+  readonly competitorBaseline: string;
+  readonly goodvibesAgent: string;
+  readonly configure: readonly string[];
+  readonly use: readonly string[];
+  readonly exceedsBy: readonly string[];
+  readonly next: readonly string[];
+}
+
+export interface OperatorCapabilityBenchmarkReport {
+  readonly generatedAt: string;
+  readonly packageName: '@pellux/goodvibes-agent';
+  readonly benchmarkSources: readonly string[];
+  readonly capabilities: readonly OperatorCapabilityBenchmark[];
+}
+
+export const OPERATOR_CAPABILITY_BENCHMARK_SOURCES = [
+  'https://github.com/openclaw/openclaw/blob/main/README.md',
+  'https://docs.openclaw.ai/help/faq',
+  'https://docs.openclaw.ai/concepts/memory',
+  'https://github.com/NousResearch/hermes-agent',
+  'https://hermes-agent.nousresearch.com/docs/user-guide/features/tools/',
+  'https://hermes-agent.nousresearch.com/docs/user-guide/features/cron/',
+  'https://hermes-agent.nousresearch.com/docs/user-guide/profiles/',
+] as const;
+
+export const OPERATOR_CAPABILITY_BENCHMARKS: readonly OperatorCapabilityBenchmark[] = [
+  {
+    id: 'terminal-operator-ui',
+    title: 'Terminal Operator UI',
+    posture: 'ready',
+    competitors: ['openclaw', 'hermes'],
+    competitorBaseline: 'Interactive CLI/TUI entry point with command discovery and persistent sessions.',
+    goodvibesAgent: 'Near-fork GoodVibes TUI shell, renderer, compositor, input, fullscreen workspace, history, command registry, and release gates.',
+    configure: ['goodvibes-agent onboarding', 'goodvibes-agent status', 'goodvibes-agent --no-alt-screen'],
+    use: ['goodvibes-agent', '/agent', '/help'],
+    exceedsBy: ['Diff-rendered GoodVibes compositor foundation', 'fullscreen operator workspace', 'strict TypeScript/Bun release gates'],
+    next: ['Continue porting more GoodVibes TUI modal/workspace affordances into Agent-first setup flows.'],
+  },
+  {
+    id: 'external-gateway',
+    title: 'Always-On Gateway / Daemon',
+    posture: 'external-daemon',
+    competitors: ['openclaw', 'hermes'],
+    competitorBaseline: 'Always-on gateway/service provides channel ingress, sessions, tools, events, and scheduled execution.',
+    goodvibesAgent: 'Connects to the GoodVibes daemon owned by GoodVibes TUI/daemon tooling; Agent never starts, stops, or owns daemon lifecycle.',
+    configure: ['goodvibes-agent compat', 'goodvibes-agent service check', 'goodvibes-agent control-plane status'],
+    use: ['goodvibes-agent status', 'goodvibes-agent doctor'],
+    exceedsBy: ['Typed SDK/operator contracts', 'explicit external-daemon boundary', 'no hidden lifecycle mutation from Agent'],
+    next: ['Improve daemon route readiness dashboard and setup diagnostics for first-run users.'],
+  },
+  {
+    id: 'multi-channel',
+    title: 'Channels And Companion Surfaces',
+    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.'],
+  },
+  {
+    id: 'isolated-knowledge-wiki',
+    title: 'Isolated Agent Knowledge / Wiki',
+    posture: 'ready',
+    competitors: ['openclaw', 'hermes'],
+    competitorBaseline: 'Persistent memory and knowledge/wiki layers with search, recall, provenance, and freshness checks.',
+    goodvibesAgent: 'Uses only /api/goodvibes-agent/knowledge/*; never falls back to default Knowledge/Wiki, HomeGraph, or Home Assistant routes.',
+    configure: ['goodvibes-agent compat', 'goodvibes-agent knowledge status'],
+    use: ['goodvibes-agent ask <question>', 'goodvibes-agent search <query>', '/knowledge ask <question>', '/knowledge ingest-url <url> --yes'],
+    exceedsBy: ['Dedicated product segment for Agent knowledge', 'route-level isolation', 'package gates that reject default wiki/HomeGraph fallback'],
+    next: ['Add richer Agent Knowledge ingestion workflows for artifacts, URLs, bookmarks, and review queues in the fullscreen workspace.'],
+  },
+  {
+    id: 'local-memory-skills-personas',
+    title: 'Local Memory, Skills, Personas, And Routines',
+    posture: 'ready',
+    competitors: ['openclaw', 'hermes'],
+    competitorBaseline: 'Skills/procedural memory, persona files, profile state, durable memory, and recurring workflows.',
+    goodvibesAgent: 'Typed local registries for Agent personas, skills, routines, and local memory; active items are injected into the serial main conversation.',
+    configure: ['/personas create ...', '/agent-skills create ...', '/routines create ...', '/memory add ...'],
+    use: ['/personas use <id>', '/skills local list', '/routines start <id>', '/memory search <query>'],
+    exceedsBy: ['Review/stale lifecycle fields', 'secret-value rejection', 'Agent-local state that does not contaminate wiki or HomeGraph'],
+    next: ['Add CLI parity for local registry lifecycle and a curated starter pack of operator skills/routines.'],
+  },
+  {
+    id: 'automation-schedules',
+    title: 'Automation, Schedules, And Routines',
+    posture: 'guarded',
+    competitors: ['openclaw', 'hermes'],
+    competitorBaseline: 'Cron/scheduler can create, pause, resume, run, remove, and deliver recurring tasks from natural language.',
+    goodvibesAgent: 'Observes public automation/schedule routes and allows only explicitly confirmed side-effecting route calls; hidden model scheduling/spawn paths are blocked.',
+    configure: ['/schedule list', '/routines create ...', 'goodvibes-agent status'],
+    use: ['/schedule list', '/routines start <id>'],
+    exceedsBy: ['No recursive hidden scheduler creation from model tools', 'explicit confirmation for side effects', 'local routines separate from daemon jobs'],
+    next: ['Build Agent-first routine-to-daemon schedule promotion flow with preview, confirmation, delivery target selection, and audit trail.'],
+  },
+  {
+    id: 'tool-gateway-mcp',
+    title: 'Tools, MCP, And Managed Integrations',
+    posture: 'configurable',
+    competitors: ['openclaw', 'hermes'],
+    competitorBaseline: 'Broad toolsets, MCP integration, browser/web/media tools, and configurable platform-specific tool availability.',
+    goodvibesAgent: 'Uses GoodVibes SDK tool registry, MCP inspection, provider tools, web search, media, plugins, and policy-gated model-visible tools.',
+    configure: ['/mcp servers', '/plugin list', 'goodvibes-agent providers', 'goodvibes-agent models'],
+    use: ['/mcp tools', '/provider current', 'goodvibes-agent search <query>'],
+    exceedsBy: ['Model-visible tool policies for read/write/network boundaries', 'typed contract gates', 'per-tool denial messages aligned with Agent product policy'],
+    next: ['Add a task-intent tool picker so only relevant tools are exposed per turn, reducing schema noise while preserving capability breadth.'],
+  },
+  {
+    id: 'voice-media-canvas',
+    title: 'Voice, Media, Canvas, And Nodes',
+    posture: 'in-progress',
+    competitors: ['openclaw', 'hermes'],
+    competitorBaseline: 'Voice/TTS, mobile nodes, live canvas, browser automation, image/video generation, and multimodal analysis.',
+    goodvibesAgent: 'Carries GoodVibes voice/media/browser/node primitives, but Agent-first setup and canvas/workspace UX still needs product wiring.',
+    configure: ['/tts status', '/provider media', '/agent'],
+    use: ['/tts speak <text>', '/image', '/media'],
+    exceedsBy: ['Shared GoodVibes media/provider substrate', 'future fullscreen workspaces can make setup inspectable and reversible'],
+    next: ['Implement Agent setup workspaces for voice, media, browser, and node surfaces with capability tests and non-leaky credential handling.'],
+  },
+  {
+    id: 'explicit-build-delegation',
+    title: 'Build/Fix/Review Delegation',
+    posture: 'explicit-delegation',
+    competitors: ['openclaw', 'hermes'],
+    competitorBaseline: 'Terminal/file/code tools and subagents can execute software tasks directly.',
+    goodvibesAgent: 'Main assistant stays serial. Explicit build/fix/review/code work is delegated to GoodVibes TUI/shared-session contracts; WRFC is opt-in only.',
+    configure: ['goodvibes-agent delegate --help', 'goodvibes-agent compat'],
+    use: ['goodvibes-agent delegate "fix the failing tests"', 'goodvibes-agent delegate --wrfc "implement and review the feature"'],
+    exceedsBy: ['Keeps personal operator brain separate from coding execution', 'delegates one authoritative TUI-owned execution chain', 'blocks local sibling agent fanout'],
+    next: ['Expose delegation receipts and artifacts in the operator workspace, with status recovery and user steering.'],
+  },
+  {
+    id: 'profiles-isolation',
+    title: 'Profiles And Isolated Operator State',
+    posture: 'ready',
+    competitors: ['hermes'],
+    competitorBaseline: 'Profiles run independent agents with isolated configs, sessions, skills, memory, cron jobs, and gateway state.',
+    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',
+    title: 'Security, Approvals, And Policy',
+    posture: 'ready',
+    competitors: ['openclaw', 'hermes'],
+    competitorBaseline: 'Command approval, DM pairing, sandboxing, allowlists, and safety defaults for exposed channels.',
+    goodvibesAgent: 'Uses daemon approvals, local auth diagnostics, secret refs, explicit confirmation gates, and Agent model-tool policy guards.',
+    configure: ['goodvibes-agent auth status', 'goodvibes-agent secrets providers', '/approvals list'],
+    use: ['/policy status', '/approvals list', 'goodvibes-agent doctor'],
+    exceedsBy: ['No token printing', 'secret-value rejection in local registries', 'policy tests for hidden spawn/lifecycle/default-knowledge failures'],
+    next: ['Add user-facing approval center in the Agent workspace with route risk labels and saved policy presets.'],
+  },
+] as const;
+
+export function buildOperatorCapabilityBenchmarkReport(now = new Date()): OperatorCapabilityBenchmarkReport {
+  return {
+    generatedAt: now.toISOString(),
+    packageName: '@pellux/goodvibes-agent',
+    benchmarkSources: OPERATOR_CAPABILITY_BENCHMARK_SOURCES,
+    capabilities: OPERATOR_CAPABILITY_BENCHMARKS,
+  };
+}
+
+export function filterOperatorCapabilities(
+  capabilities: readonly OperatorCapabilityBenchmark[],
+  query: string | undefined,
+): readonly OperatorCapabilityBenchmark[] {
+  const normalized = query?.trim().toLowerCase();
+  if (!normalized) return capabilities;
+  return capabilities.filter((capability) => {
+    if (capability.id.includes(normalized)) return true;
+    if (capability.title.toLowerCase().includes(normalized)) return true;
+    if (capability.posture.includes(normalized)) return true;
+    if (capability.competitors.some((competitor) => competitor === normalized)) return true;
+    return capability.goodvibesAgent.toLowerCase().includes(normalized)
+      || capability.competitorBaseline.toLowerCase().includes(normalized);
+  });
+}
+
+export function renderOperatorCapabilityBenchmark(
+  capabilities: readonly OperatorCapabilityBenchmark[] = OPERATOR_CAPABILITY_BENCHMARKS,
+): string {
+  const lines: string[] = [
+    'GoodVibes Agent capability benchmark',
+    '  Goal: match and exceed OpenClaw/Hermes personal-operator capabilities without default wiki/HomeGraph fallback or hidden local agent fanout.',
+    '',
+  ];
+
+  for (const capability of capabilities) {
+    lines.push(`${capability.title} [${capability.posture}]`);
+    lines.push(`  competitors: ${capability.competitors.join(', ')}`);
+    lines.push(`  baseline: ${capability.competitorBaseline}`);
+    lines.push(`  Agent: ${capability.goodvibesAgent}`);
+    lines.push(`  configure: ${capability.configure.join(' | ')}`);
+    lines.push(`  use: ${capability.use.join(' | ')}`);
+    lines.push(`  exceeds: ${capability.exceedsBy.join(' | ')}`);
+    lines.push(`  next: ${capability.next.join(' | ')}`);
+    lines.push('');
+  }
+
+  lines.push('Sources:');
+  for (const source of OPERATOR_CAPABILITY_BENCHMARK_SOURCES) lines.push(`  ${source}`);
+  return lines.join('\n');
+}

package/src/tools/agent-context-policy.ts

@@ -0,0 +1,24 @@
+import type { Tool } from '@pellux/goodvibes-sdk/platform/types';
+
+const CONTEXT_TOOL_DENIAL = [
+  'GoodVibes Agent does not expose copied GoodVibes runtime context through model tools in the main conversation.',
+  'The copied context tool can describe TUI/default runtime assumptions that are not the Agent product boundary.',
+  'Use explicit Agent CLI/slash commands such as status, compat, capabilities, and isolated Agent Knowledge instead.',
+].join(' ');
+
+export function wrapBlockedContextToolForAgentPolicy(tool: Tool): void {
+  tool.definition.description = [
+    'Blocked in GoodVibes Agent main conversation: copied runtime context.',
+    'Use explicit Agent CLI/slash status, compat, capabilities, and Agent Knowledge commands for product-scoped context.',
+    'Default Knowledge/Wiki, HomeGraph, and copied TUI runtime assumptions are not Agent fallbacks.',
+  ].join(' ');
+  tool.definition.sideEffects = [];
+  tool.definition.parameters = {
+    type: 'object',
+    properties: {},
+    additionalProperties: false,
+  };
+  tool.execute = async () => ({ success: false, error: CONTEXT_TOOL_DENIAL });
+}
+
+export const AGENT_CONTEXT_TOOL_DENIAL_MESSAGE = CONTEXT_TOOL_DENIAL;

package/src/tools/wrfc-agent-guard.ts

@@ -4,6 +4,9 @@ import {
   wrapAnalyzeToolForAgentPolicy,
   wrapRegistryToolForAgentPolicy,
 } from './agent-analysis-registry-policy.ts';
+import {
+  wrapBlockedContextToolForAgentPolicy,
+} from './agent-context-policy.ts';
 import { wrapFindToolForAgentPolicy } from './agent-find-policy.ts';
 import { wrapReadToolForAgentPolicy } from './agent-read-policy.ts';
 import { wrapWebSearchToolForAgentPolicy } from './agent-web-search-policy.ts';
@@ -227,6 +230,8 @@ export function installAgentToolPolicyGuard(registry: ToolRegistry, options: Age
       wrapFetchToolForAgentPolicy(tool);
     } else if (tool.definition.name === 'state') {
       wrapStateToolForAgentPolicy(tool);
+    } else if (tool.definition.name === 'goodvibes_context') {
+      wrapBlockedContextToolForAgentPolicy(tool);
     } else if (tool.definition.name === 'goodvibes_settings') {
       wrapBlockedSettingsToolForAgentPolicy(tool);
     } else if (tool.definition.name === 'inspect') {
@@ -551,6 +556,11 @@ export const AGENT_INSPECT_WRITE_DENIAL_MESSAGE = INSPECT_WRITE_DENIAL;
 export const AGENT_DURABLE_WORKFLOW_MUTATION_DENIAL_MESSAGE = DURABLE_WORKFLOW_MUTATION_DENIAL;
 export const AGENT_CONTROL_MUTATION_DENIAL_MESSAGE = CONTROL_MUTATION_DENIAL;
 
+export {
+  AGENT_CONTEXT_TOOL_DENIAL_MESSAGE,
+  wrapBlockedContextToolForAgentPolicy,
+} from './agent-context-policy.ts';
+
 export {
   AGENT_ANALYZE_NETWORK_DENIAL_MESSAGE,
   AGENT_READ_ONLY_ANALYZE_TOOL_MODES,

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