@pellux/goodvibes-agent 0.1.40 → 0.1.41

package/CHANGELOG.md

@@ -2,6 +2,10 @@
 
 All notable changes to GoodVibes Agent will be recorded here.
 
+## 0.1.41 - 2026-05-31
+
+- c108e13 Add live daemon capability audit
+
 ## 0.1.40 - 2026-05-31
 
 - 329dc13 Add routine schedule delivery targets

package/README.md

@@ -16,6 +16,7 @@ bun add -g @pellux/goodvibes-agent
 goodvibes-agent --help
 goodvibes-agent status
 goodvibes-agent capabilities
+goodvibes-agent capabilities daemon
 ```
 
 If Bun reports untrusted lifecycle dependencies, trust only the package and dependencies required by this package:
@@ -44,7 +45,7 @@ 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 `goodvibes-agent capabilities` or `/capabilities` to inspect the OpenClaw/Hermes benchmark, current Agent posture, configuration commands, usage paths, and remaining gaps. Use `goodvibes-agent capabilities daemon` or `/capabilities daemon` for a live read-only audit of the GoodVibes daemon method catalog and isolated Agent Knowledge route coverage.
 
 Inside the workspace, use `/agent-profile guide` to author custom profile starters without leaving the Agent TUI. The guided flow lists starters, exports starter JSON, imports edited local starters, and creates isolated runtime profiles from them.
 
@@ -81,6 +82,15 @@ Starting a routine records local usage and prints its steps; it does not spawn b
 
 Start or restart the daemon from GoodVibes TUI or the daemon host before launching Agent. Agent status and companion/knowledge routes connect to that external daemon, normally on `http://127.0.0.1:3421`.
 
+To verify what the running daemon can expose for the Agent/OpenClaw/Hermes capability benchmark:
+
+```sh
+goodvibes-agent capabilities daemon
+goodvibes-agent capabilities daemon --json
+```
+
+This audit checks `/api/control-plane/methods` and `/api/goodvibes-agent/knowledge/status`. It does not query default Knowledge/Wiki or HomeGraph.
+
 Agent intentionally blocks daemon lifecycle commands:
 
 ```sh

package/docs/operator-capability-benchmark.md

@@ -15,6 +15,9 @@ Use the live benchmark from the package:
 goodvibes-agent capabilities
 goodvibes-agent capabilities --json
 goodvibes-agent capabilities hermes
+goodvibes-agent capabilities daemon
+goodvibes-agent capabilities daemon --json
+goodvibes-agent capabilities daemon knowledge
 ```
 
 Inside the TUI:
@@ -23,6 +26,7 @@ Inside the TUI:
 /capabilities
 /capabilities openclaw
 /capabilities knowledge
+/capabilities daemon
 ```
 
 ## Research Baseline
@@ -52,6 +56,8 @@ The benchmark measures two different GoodVibes layers:
 
 If the daemon already has a route but Agent lacks a good setup/workspace/CLI surface, the gap is treated as an Agent product gap rather than a missing platform capability.
 
+Use `goodvibes-agent capabilities daemon` for the live read-only daemon audit. It checks the public control-plane method catalog and the isolated Agent Knowledge status route. It intentionally does not call default `/api/knowledge/*`, HomeGraph, or Home Assistant routes.
+
 ## Capability Targets
 
 | Area | OpenClaw/Hermes Baseline | GoodVibes Agent Position |

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pellux/goodvibes-agent",
-  "version": "0.1.40",
+  "version": "0.1.41",
   "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/cli/capabilities-command.ts

@@ -5,16 +5,51 @@ import {
   filterOperatorCapabilities,
   renderOperatorCapabilityBenchmark,
 } from '../operator/capability-benchmark.ts';
+import {
+  fetchLiveDaemonCapabilityAudit,
+  filterDaemonCapabilityAuditAreas,
+  renderDaemonCapabilityAudit,
+  renderDaemonCapabilityFailure,
+} from '../operator/daemon-capability-audit.ts';
+import { resolveAgentDaemonConnection } from '../agent/routine-schedule-promotion.ts';
+
+interface CapabilityCommandArgs {
+  readonly mode: 'benchmark' | 'daemon';
+  readonly query: string | undefined;
+}
 
-function readCapabilityQuery(args: readonly string[]): string | undefined {
+function readCapabilityArgs(args: readonly string[]): CapabilityCommandArgs {
   const values = args.filter((arg) => !arg.startsWith('--'));
-  return values.length > 0 ? values.join(' ') : undefined;
+  if (values[0] === 'daemon') {
+    const query = values.slice(1).join(' ').trim();
+    return { mode: 'daemon', query: query.length > 0 ? query : undefined };
+  }
+  return { mode: 'benchmark', query: values.length > 0 ? values.join(' ') : undefined };
 }
 
 export async function handleCapabilitiesCommand(runtime: CliCommandRuntime): Promise<CliCommandOutput> {
-  const query = readCapabilityQuery(runtime.cli.commandArgs);
+  const args = readCapabilityArgs(runtime.cli.commandArgs);
+  if (args.mode === 'daemon') {
+    const connection = resolveAgentDaemonConnection(runtime.configManager, runtime.homeDirectory);
+    const audit = await fetchLiveDaemonCapabilityAudit(connection);
+    if (!audit.ok) {
+      return {
+        output: runtime.cli.flags.outputFormat === 'json'
+          ? JSON.stringify(audit, null, 2)
+          : renderDaemonCapabilityFailure(audit),
+        exitCode: audit.kind === 'auth_required' || audit.kind === 'daemon_unavailable' ? 1 : 2,
+      };
+    }
+    const areas = filterDaemonCapabilityAuditAreas(audit.areas, args.query);
+    return {
+      output: runtime.cli.flags.outputFormat === 'json'
+        ? JSON.stringify({ ...audit, areas }, null, 2)
+        : renderDaemonCapabilityAudit(audit, areas),
+      exitCode: 0,
+    };
+  }
   const report = buildOperatorCapabilityBenchmarkReport();
-  const capabilities = filterOperatorCapabilities(report.capabilities, query);
+  const capabilities = filterOperatorCapabilities(report.capabilities, args.query);
   if (runtime.cli.flags.outputFormat === 'json') {
     return {
       output: JSON.stringify({ ...report, capabilities }, null, 2),

package/src/cli/help.ts

@@ -42,7 +42,7 @@ export function renderGoodVibesHelp(binary = 'goodvibes-agent'): string {
     '  routines                   Inspect local routines and explicitly promote one to a daemon schedule',
     '  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',
+    '  capabilities               Show OpenClaw/Hermes benchmark and live daemon coverage',
     '  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',
@@ -102,6 +102,7 @@ export function renderGoodVibesHelp(binary = 'goodvibes-agent'): string {
     `  ${binary} routines promote daily-operations-sweep --cron "0 9 * * *" --timezone America/Chicago --yes`,
     `  ${binary} compat`,
     `  ${binary} capabilities`,
+    `  ${binary} capabilities daemon`,
     `  ${binary} knowledge status`,
     `  ${binary} knowledge ask "What is GoodVibes Agent?"`,
     `  ${binary} ask "What is GoodVibes Agent?"`,
@@ -196,9 +197,9 @@ const COMMAND_HELP: Record<string, CommandHelp> = {
     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'],
+    usage: ['capabilities [openclaw|hermes|query]', 'capabilities daemon [query]', 'capabilities --json'],
+    summary: 'Show the OpenClaw/Hermes capability benchmark, Agent readiness, and live GoodVibes daemon method coverage.',
+    examples: ['capabilities', 'capabilities hermes', 'capabilities daemon', 'capabilities daemon knowledge --json'],
   },
   knowledge: {
     usage: [

package/src/input/commands/capabilities-runtime.ts

@@ -4,14 +4,34 @@ import {
   renderOperatorCapabilityBenchmark,
   OPERATOR_CAPABILITY_BENCHMARKS,
 } from '../../operator/capability-benchmark.ts';
+import {
+  fetchLiveDaemonCapabilityAudit,
+  filterDaemonCapabilityAuditAreas,
+  renderDaemonCapabilityAudit,
+  renderDaemonCapabilityFailure,
+} from '../../operator/daemon-capability-audit.ts';
+import { resolveAgentDaemonConnection } from '../../agent/routine-schedule-promotion.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) {
+    description: 'Show the OpenClaw/Hermes capability benchmark, Agent readiness, and live daemon coverage',
+    usage: '[daemon|openclaw|hermes|query]',
+    async handler(args, ctx) {
+      if (args[0] === 'daemon') {
+        const homeDirectory = ctx.platform.configManager.getHomeDirectory() ?? process.cwd();
+        const connection = resolveAgentDaemonConnection(ctx.platform.configManager, homeDirectory);
+        const audit = await fetchLiveDaemonCapabilityAudit(connection);
+        if (!audit.ok) {
+          ctx.print(renderDaemonCapabilityFailure(audit));
+          return;
+        }
+        const query = args.slice(1).join(' ').trim() || undefined;
+        const areas = filterDaemonCapabilityAuditAreas(audit.areas, query);
+        ctx.print(renderDaemonCapabilityAudit(audit, areas));
+        return;
+      }
       const query = args.join(' ').trim() || undefined;
       const capabilities = filterOperatorCapabilities(OPERATOR_CAPABILITY_BENCHMARKS, query);
       ctx.print(renderOperatorCapabilityBenchmark(capabilities));

package/src/operator/capability-benchmark.ts

@@ -211,6 +211,7 @@ export function filterOperatorCapabilities(
     if (capability.posture.includes(normalized)) return true;
     if (capability.competitors.some((competitor) => competitor === normalized)) return true;
     return capability.goodvibesAgent.toLowerCase().includes(normalized)
+      || capability.goodvibesDaemon?.toLowerCase().includes(normalized) === true
       || capability.competitorBaseline.toLowerCase().includes(normalized);
   });
 }

package/src/operator/daemon-capability-audit.ts

@@ -0,0 +1,554 @@
+import { summarizeError } from '@pellux/goodvibes-sdk/platform/utils';
+import { SDK_VERSION } from '../version.ts';
+import type { AgentDaemonConnection } from '../agent/routine-schedule-promotion.ts';
+
+export const DAEMON_METHOD_CATALOG_ROUTE = '/api/control-plane/methods';
+export const AGENT_KNOWLEDGE_STATUS_ROUTE = '/api/goodvibes-agent/knowledge/status';
+export const DAEMON_STATUS_ROUTE = '/status';
+
+export type DaemonCapabilityAuditFailureKind =
+  | 'auth_required'
+  | 'daemon_unavailable'
+  | 'version_mismatch'
+  | 'daemon_route_unavailable'
+  | 'daemon_error';
+
+export type DaemonCapabilityCoverage = 'ready' | 'partial' | 'missing';
+export type DaemonCapabilityRouteCoverage = 'ready' | 'missing' | 'not_checked';
+
+export interface DaemonCapabilityRequirement {
+  readonly id: string;
+  readonly title: string;
+  readonly competitorBaseline: string;
+  readonly agentUse: string;
+  readonly requiredMethodIds: readonly string[];
+  readonly optionalMethodIds: readonly string[];
+  readonly requiredAgentRoutes: readonly string[];
+  readonly next: readonly string[];
+}
+
+export interface DaemonCapabilityAuditArea {
+  readonly id: string;
+  readonly title: string;
+  readonly coverage: DaemonCapabilityCoverage;
+  readonly competitorBaseline: string;
+  readonly agentUse: string;
+  readonly presentRequiredMethodIds: readonly string[];
+  readonly missingRequiredMethodIds: readonly string[];
+  readonly presentOptionalMethodIds: readonly string[];
+  readonly missingOptionalMethodIds: readonly string[];
+  readonly agentRoutes: readonly {
+    readonly route: string;
+    readonly coverage: DaemonCapabilityRouteCoverage;
+  }[];
+  readonly next: readonly string[];
+}
+
+export interface DaemonCapabilityAuditSuccess {
+  readonly ok: true;
+  readonly kind: 'daemon.capabilities.audit';
+  readonly baseUrl: string;
+  readonly daemonVersion: string;
+  readonly expectedSdkVersion: string;
+  readonly daemonCompatible: boolean;
+  readonly methodCatalogRoute: typeof DAEMON_METHOD_CATALOG_ROUTE;
+  readonly methodCount: number;
+  readonly agentKnowledgeRoute: typeof AGENT_KNOWLEDGE_STATUS_ROUTE;
+  readonly agentKnowledgeRouteReady: boolean;
+  readonly defaultKnowledgeFallback: false;
+  readonly homeGraphFallback: false;
+  readonly warnings: readonly string[];
+  readonly areas: readonly DaemonCapabilityAuditArea[];
+}
+
+export interface DaemonCapabilityAuditFailure {
+  readonly ok: false;
+  readonly kind: DaemonCapabilityAuditFailureKind;
+  readonly error: string;
+  readonly baseUrl: string;
+  readonly route: string;
+  readonly daemonVersion?: string;
+  readonly expectedSdkVersion?: string;
+}
+
+export type DaemonCapabilityAuditResult =
+  | DaemonCapabilityAuditSuccess
+  | DaemonCapabilityAuditFailure;
+
+interface DaemonMethodSummary {
+  readonly id: string;
+  readonly title?: string;
+  readonly category?: string;
+  readonly invokable?: boolean;
+  readonly access?: string;
+  readonly http?: {
+    readonly method?: string;
+    readonly path?: string;
+  };
+}
+
+interface FetchJsonResult {
+  readonly ok: boolean;
+  readonly status: number;
+  readonly statusText: string;
+  readonly body: unknown;
+}
+
+export const DAEMON_CAPABILITY_REQUIREMENTS: readonly DaemonCapabilityRequirement[] = [
+  {
+    id: 'gateway-control',
+    title: 'Gateway Control Plane',
+    competitorBaseline: 'OpenClaw/Hermes expose an always-on gateway with health, auth, method discovery, and events.',
+    agentUse: 'Agent connects to the existing GoodVibes daemon, inspects posture, and never starts or owns daemon lifecycle.',
+    requiredMethodIds: [
+      'control.status',
+      'control.auth.current',
+      'control.methods.list',
+      'control.contract',
+      'control.snapshot',
+    ],
+    optionalMethodIds: ['control.clients.list', 'control.events.catalog', 'control.events.stream', 'control.web'],
+    requiredAgentRoutes: [],
+    next: ['Add richer first-run guidance when auth or route contract checks fail.'],
+  },
+  {
+    id: 'chat-sessions',
+    title: 'Companion Chat And Shared Sessions',
+    competitorBaseline: 'Personal agents keep persistent chat and can route larger work through task/session surfaces.',
+    agentUse: 'Agent uses companion.chat for normal turns and shared sessions only for explicit TUI build/fix/review delegation.',
+    requiredMethodIds: [
+      'companion.chat.sessions.create',
+      'companion.chat.sessions.get',
+      'companion.chat.sessions.list',
+      'companion.chat.messages.create',
+      'companion.chat.messages.list',
+      'sessions.create',
+      'sessions.messages.create',
+      'sessions.list',
+    ],
+    optionalMethodIds: ['companion.chat.events.stream', 'sessions.followUp', 'sessions.steer', 'sessions.integration.snapshot'],
+    requiredAgentRoutes: [],
+    next: ['Expose delegated session artifacts and status in the operator workspace without making WRFC default.'],
+  },
+  {
+    id: 'channels',
+    title: 'Channels And Delivery Gateway',
+    competitorBaseline: 'Gateway products receive and send across Slack, Discord, webhooks, mobile, and companion surfaces.',
+    agentUse: 'Agent inspects channel readiness and uses explicit delivery targets for scheduled routine promotion.',
+    requiredMethodIds: [
+      'channels.status',
+      'channels.capabilities.list',
+      'channels.accounts.list',
+      'channels.setup.get',
+      'channels.doctor.get',
+      'channels.actions.list',
+      'channels.tools.list',
+      'channels.targets.resolve',
+      'channels.policies.list',
+    ],
+    optionalMethodIds: [
+      'channels.directory.query',
+      'channels.allowlist.resolve',
+      'channels.policies.audit',
+      'channels.agent_tools.list',
+      'channels.authorize',
+    ],
+    requiredAgentRoutes: [],
+    next: ['Surface live per-account delivery errors and setup repairs in the Agent workspace.'],
+  },
+  {
+    id: 'agent-knowledge',
+    title: 'Isolated Agent Knowledge',
+    competitorBaseline: 'Persistent knowledge and memory are core personal-operator features.',
+    agentUse: 'Agent Knowledge is a separate product segment under /api/goodvibes-agent/knowledge/* with no default wiki or HomeGraph fallback.',
+    requiredMethodIds: [],
+    optionalMethodIds: [],
+    requiredAgentRoutes: [AGENT_KNOWLEDGE_STATUS_ROUTE],
+    next: ['Add artifact and multimodal ingestion UX only against the isolated Agent Knowledge route family.'],
+  },
+  {
+    id: 'automation-schedules',
+    title: 'Automation, Schedules, Runs, And Capacity',
+    competitorBaseline: 'Hermes/OpenClaw-style operators can schedule, run, pause, resume, and inspect recurring work.',
+    agentUse: 'Agent observes automation and promotes local routines to daemon schedules only through explicit confirmed commands.',
+    requiredMethodIds: [
+      'automation.integration.snapshot',
+      'automation.jobs.list',
+      'automation.runs.list',
+      'automation.heartbeat.list',
+      'schedules.list',
+      'schedules.create',
+      'scheduler.capacity',
+    ],
+    optionalMethodIds: [
+      'automation.jobs.run',
+      'automation.jobs.pause',
+      'automation.jobs.resume',
+      'automation.runs.cancel',
+      'automation.runs.retry',
+      'schedules.run',
+      'schedules.enable',
+      'schedules.disable',
+      'schedules.delete',
+    ],
+    requiredAgentRoutes: [],
+    next: ['Add live delivery/run history and failed delivery diagnostics for promoted Agent routines.'],
+  },
+  {
+    id: 'approvals-security',
+    title: 'Approvals, Policy, And Channel Safety',
+    competitorBaseline: 'Exposed agents need approval gates, pairing, allowlists, and policy inspection.',
+    agentUse: 'Agent keeps destructive or external effects behind exact commands plus confirmation and uses daemon approvals.',
+    requiredMethodIds: [
+      'approvals.list',
+      'approvals.approve',
+      'approvals.deny',
+      'approvals.cancel',
+      'channels.policies.list',
+      'channels.policies.audit',
+    ],
+    optionalMethodIds: ['approvals.claim', 'channels.allowlist.edit', 'channels.allowlist.resolve'],
+    requiredAgentRoutes: [],
+    next: ['Build a route-risk-aware approval center in the fullscreen Agent workspace.'],
+  },
+  {
+    id: 'mcp-tools-artifacts',
+    title: 'MCP, Tools, Artifacts, And Web Search',
+    competitorBaseline: 'Modern personal operators expose managed tools, MCP servers, artifacts, and web/research tools.',
+    agentUse: 'Agent uses GoodVibes daemon tool surfaces through public SDK contracts and policy-gated model visibility.',
+    requiredMethodIds: [
+      'mcp.config.get',
+      'mcp.servers.list',
+      'mcp.tools.list',
+      'artifacts.create',
+      'artifacts.get',
+      'artifacts.list',
+      'web_search.providers.list',
+      'web_search.query',
+    ],
+    optionalMethodIds: ['artifacts.content.get', 'mcp.config.reload'],
+    requiredAgentRoutes: [],
+    next: ['Add per-turn tool-palette narrowing so broad tool capability does not create noisy model schemas.'],
+  },
+  {
+    id: 'voice-media-nodes',
+    title: 'Voice, Media, Multimodal, And Remote Nodes',
+    competitorBaseline: 'OpenClaw/Hermes expose voice, media, mobile/node, and multimodal surfaces.',
+    agentUse: 'Agent inspects daemon voice/media/remote readiness and keeps execution explicit or read-only until user-selected.',
+    requiredMethodIds: [
+      'voice.status',
+      'voice.providers.list',
+      'voice.voices.list',
+      'voice.tts',
+      'voice.stt',
+      'media.providers.list',
+      'media.analyze',
+      'multimodal.providers.list',
+      'remote.snapshot',
+      'remote.peers.list',
+      'remote.work.list',
+      'remote.node_host.contract',
+    ],
+    optionalMethodIds: [
+      'voice.realtime.session',
+      'voice.tts.stream',
+      'media.generate',
+      'media.transform',
+      'multimodal.analyze',
+      'remote.peers.invoke',
+    ],
+    requiredAgentRoutes: [],
+    next: ['Turn daemon readiness into Agent setup cards for voice, media, browser, and node workflows.'],
+  },
+  {
+    id: 'providers-models',
+    title: 'Providers, Models, And Usage',
+    competitorBaseline: 'Personal operators need configurable providers, model routing, and usage posture.',
+    agentUse: 'Agent reads daemon provider/model state, keeps provider+model routing explicit, and avoids per-message routing hacks.',
+    requiredMethodIds: ['providers.list', 'providers.get', 'providers.usage.get'],
+    optionalMethodIds: ['accounts.snapshot'],
+    requiredAgentRoutes: [],
+    next: ['Add provider/model readiness remediation directly into onboarding/config workspaces.'],
+  },
+] as const;
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return Boolean(value) && typeof value === 'object' && !Array.isArray(value);
+}
+
+function readString(record: Record<string, unknown>, key: string): string | null {
+  const value = record[key];
+  return typeof value === 'string' ? value : null;
+}
+
+function readMethodSummaries(body: unknown): readonly DaemonMethodSummary[] {
+  const methods = isRecord(body) && Array.isArray(body.methods) ? body.methods : [];
+  return methods.flatMap((value): DaemonMethodSummary[] => {
+    if (!isRecord(value)) return [];
+    const id = readString(value, 'id');
+    if (!id) return [];
+    const httpRecord = isRecord(value.http) ? value.http : null;
+    return [{
+      id,
+      title: readString(value, 'title') ?? undefined,
+      category: readString(value, 'category') ?? undefined,
+      access: readString(value, 'access') ?? undefined,
+      invokable: typeof value.invokable === 'boolean' ? value.invokable : undefined,
+      http: httpRecord
+        ? {
+            method: readString(httpRecord, 'method') ?? undefined,
+            path: readString(httpRecord, 'path') ?? undefined,
+          }
+        : undefined,
+    }];
+  });
+}
+
+function daemonVersionFromStatus(body: unknown): string {
+  if (!isRecord(body)) return 'unknown';
+  return readString(body, 'version')
+    ?? readString(body, 'sdkVersion')
+    ?? 'unknown';
+}
+
+function buildHeaders(connection: AgentDaemonConnection): Headers {
+  const headers = new Headers({ accept: 'application/json' });
+  if (connection.token) headers.set('authorization', `Bearer ${connection.token}`);
+  return headers;
+}
+
+async function fetchJson(connection: AgentDaemonConnection, route: string): Promise<FetchJsonResult> {
+  const response = await fetch(`${connection.baseUrl}${route}`, {
+    method: 'GET',
+    headers: buildHeaders(connection),
+  });
+  const text = await response.text();
+  let body: unknown = text;
+  if (text.trim().length > 0) {
+    try {
+      body = JSON.parse(text) as unknown;
+    } catch {
+      body = text;
+    }
+  }
+  return {
+    ok: response.ok,
+    status: response.status,
+    statusText: response.statusText,
+    body,
+  };
+}
+
+function failureFromResponse(
+  response: FetchJsonResult,
+  connection: AgentDaemonConnection,
+  route: string,
+  daemonVersion: string,
+): DaemonCapabilityAuditFailure {
+  const detail = isRecord(response.body) && typeof response.body.error === 'string'
+    ? response.body.error
+    : typeof response.body === 'string'
+      ? response.body
+      : response.statusText;
+  const error = `HTTP ${response.status}${detail ? `: ${detail}` : ''}`;
+  if (response.status === 401 || response.status === 403) {
+    return { ok: false, kind: 'auth_required', error, baseUrl: connection.baseUrl, route };
+  }
+  if (response.status === 404 && daemonVersion !== 'unknown' && daemonVersion !== SDK_VERSION) {
+    return {
+      ok: false,
+      kind: 'version_mismatch',
+      error: `External daemon SDK version ${daemonVersion} does not match Agent SDK pin ${SDK_VERSION}; ${route} is unavailable.`,
+      baseUrl: connection.baseUrl,
+      route,
+      daemonVersion,
+      expectedSdkVersion: SDK_VERSION,
+    };
+  }
+  if (response.status === 404) {
+    return { ok: false, kind: 'daemon_route_unavailable', error, baseUrl: connection.baseUrl, route };
+  }
+  return { ok: false, kind: 'daemon_error', error, baseUrl: connection.baseUrl, route };
+}
+
+function failureFromThrown(error: unknown, connection: AgentDaemonConnection, route: string): DaemonCapabilityAuditFailure {
+  const message = summarizeError(error);
+  const lower = message.toLowerCase();
+  if (lower.includes('unauthorized') || lower.includes('401') || lower.includes('403')) {
+    return { ok: false, kind: 'auth_required', error: message, baseUrl: connection.baseUrl, route };
+  }
+  if (lower.includes('fetch') || lower.includes('connect') || lower.includes('econnrefused')) {
+    return { ok: false, kind: 'daemon_unavailable', error: message, baseUrl: connection.baseUrl, route };
+  }
+  if (lower.includes('404') || lower.includes('not found')) {
+    return { ok: false, kind: 'daemon_route_unavailable', error: message, baseUrl: connection.baseUrl, route };
+  }
+  return { ok: false, kind: 'daemon_error', error: message, baseUrl: connection.baseUrl, route };
+}
+
+export function buildDaemonCapabilityAuditAreas(
+  methodIds: ReadonlySet<string>,
+  agentKnowledgeRouteReady: boolean | null,
+): readonly DaemonCapabilityAuditArea[] {
+  return DAEMON_CAPABILITY_REQUIREMENTS.map((requirement) => {
+    const presentRequiredMethodIds = requirement.requiredMethodIds.filter((methodId) => methodIds.has(methodId));
+    const missingRequiredMethodIds = requirement.requiredMethodIds.filter((methodId) => !methodIds.has(methodId));
+    const presentOptionalMethodIds = requirement.optionalMethodIds.filter((methodId) => methodIds.has(methodId));
+    const missingOptionalMethodIds = requirement.optionalMethodIds.filter((methodId) => !methodIds.has(methodId));
+    const agentRoutes = requirement.requiredAgentRoutes.map((route) => ({
+      route,
+      coverage: agentKnowledgeRouteReady === null
+        ? 'not_checked'
+        : agentKnowledgeRouteReady
+          ? 'ready'
+          : 'missing',
+    } satisfies DaemonCapabilityAuditArea['agentRoutes'][number]));
+    const missingAgentRoutes = agentRoutes.filter((route) => route.coverage === 'missing');
+    const requiredCount = requirement.requiredMethodIds.length + requirement.requiredAgentRoutes.length;
+    const presentRequiredCount = presentRequiredMethodIds.length
+      + agentRoutes.filter((route) => route.coverage === 'ready').length;
+    const coverage: DaemonCapabilityCoverage = requiredCount === presentRequiredCount
+      ? 'ready'
+      : presentRequiredCount > 0 && missingRequiredMethodIds.length + missingAgentRoutes.length < requiredCount
+        ? 'partial'
+        : 'missing';
+    return {
+      id: requirement.id,
+      title: requirement.title,
+      coverage,
+      competitorBaseline: requirement.competitorBaseline,
+      agentUse: requirement.agentUse,
+      presentRequiredMethodIds,
+      missingRequiredMethodIds,
+      presentOptionalMethodIds,
+      missingOptionalMethodIds,
+      agentRoutes,
+      next: requirement.next,
+    };
+  });
+}
+
+export async function fetchLiveDaemonCapabilityAudit(
+  connection: AgentDaemonConnection,
+): Promise<DaemonCapabilityAuditResult> {
+  let daemonVersion = 'unknown';
+  try {
+    const status = await fetchJson(connection, DAEMON_STATUS_ROUTE);
+    if (status.ok) {
+      daemonVersion = daemonVersionFromStatus(status.body);
+    } else if (status.status === 401 || status.status === 403) {
+      return failureFromResponse(status, connection, DAEMON_STATUS_ROUTE, daemonVersion);
+    }
+
+    const methods = await fetchJson(connection, DAEMON_METHOD_CATALOG_ROUTE);
+    if (!methods.ok) return failureFromResponse(methods, connection, DAEMON_METHOD_CATALOG_ROUTE, daemonVersion);
+
+    const methodSummaries = readMethodSummaries(methods.body);
+    const methodIds = new Set(methodSummaries.map((method) => method.id));
+    const warnings: string[] = [];
+    const daemonCompatible = daemonVersion === SDK_VERSION;
+    if (daemonVersion !== 'unknown' && !daemonCompatible) {
+      warnings.push(`External daemon SDK version ${daemonVersion} does not match Agent SDK pin ${SDK_VERSION}.`);
+    }
+
+    const agentKnowledge = await fetchJson(connection, AGENT_KNOWLEDGE_STATUS_ROUTE);
+    if (!agentKnowledge.ok) {
+      const failure = failureFromResponse(agentKnowledge, connection, AGENT_KNOWLEDGE_STATUS_ROUTE, daemonVersion);
+      if (failure.kind === 'auth_required') return failure;
+      warnings.push(`${AGENT_KNOWLEDGE_STATUS_ROUTE} is not ready: ${failure.error}`);
+    }
+
+    return {
+      ok: true,
+      kind: 'daemon.capabilities.audit',
+      baseUrl: connection.baseUrl,
+      daemonVersion,
+      expectedSdkVersion: SDK_VERSION,
+      daemonCompatible,
+      methodCatalogRoute: DAEMON_METHOD_CATALOG_ROUTE,
+      methodCount: methodSummaries.length,
+      agentKnowledgeRoute: AGENT_KNOWLEDGE_STATUS_ROUTE,
+      agentKnowledgeRouteReady: agentKnowledge.ok,
+      defaultKnowledgeFallback: false,
+      homeGraphFallback: false,
+      warnings,
+      areas: buildDaemonCapabilityAuditAreas(methodIds, agentKnowledge.ok),
+    };
+  } catch (error) {
+    return failureFromThrown(error, connection, daemonVersion === 'unknown' ? DAEMON_STATUS_ROUTE : DAEMON_METHOD_CATALOG_ROUTE);
+  }
+}
+
+export function filterDaemonCapabilityAuditAreas(
+  areas: readonly DaemonCapabilityAuditArea[],
+  query: string | undefined,
+): readonly DaemonCapabilityAuditArea[] {
+  const normalized = query?.trim().toLowerCase();
+  if (!normalized) return areas;
+  return areas.filter((area) => {
+    if (area.id.includes(normalized)) return true;
+    if (area.title.toLowerCase().includes(normalized)) return true;
+    if (area.coverage.includes(normalized)) return true;
+    if (area.agentUse.toLowerCase().includes(normalized)) return true;
+    return area.presentRequiredMethodIds.some((methodId) => methodId.includes(normalized))
+      || area.missingRequiredMethodIds.some((methodId) => methodId.includes(normalized))
+      || area.presentOptionalMethodIds.some((methodId) => methodId.includes(normalized))
+      || area.missingOptionalMethodIds.some((methodId) => methodId.includes(normalized))
+      || area.agentRoutes.some((route) => route.route.toLowerCase().includes(normalized));
+  });
+}
+
+export function renderDaemonCapabilityAudit(
+  audit: DaemonCapabilityAuditSuccess,
+  areas: readonly DaemonCapabilityAuditArea[] = audit.areas,
+): string {
+  const lines: string[] = [
+    'GoodVibes daemon capability audit',
+    `  daemon: ${audit.baseUrl}`,
+    `  SDK: Agent expects ${audit.expectedSdkVersion}; daemon reports ${audit.daemonVersion}`,
+    `  compatibility: ${audit.daemonCompatible ? 'matched' : 'mismatch'}`,
+    `  method catalog: ${audit.methodCount} methods from ${audit.methodCatalogRoute}`,
+    `  Agent Knowledge: ${audit.agentKnowledgeRouteReady ? 'ready' : 'missing'} ${audit.agentKnowledgeRoute}`,
+    '  isolation: default Knowledge/Wiki fallback no; HomeGraph fallback no',
+    '',
+  ];
+
+  for (const warning of audit.warnings) lines.push(`  warning: ${warning}`);
+  if (audit.warnings.length > 0) lines.push('');
+
+  for (const area of areas) {
+    const requiredTotal = area.presentRequiredMethodIds.length + area.missingRequiredMethodIds.length;
+    const optionalTotal = area.presentOptionalMethodIds.length + area.missingOptionalMethodIds.length;
+    lines.push(`${area.title} [${area.coverage}]`);
+    lines.push(`  baseline: ${area.competitorBaseline}`);
+    lines.push(`  Agent use: ${area.agentUse}`);
+    lines.push(`  required methods: ${area.presentRequiredMethodIds.length}/${requiredTotal}`);
+    if (area.missingRequiredMethodIds.length > 0) lines.push(`  missing required: ${area.missingRequiredMethodIds.join(', ')}`);
+    if (optionalTotal > 0) {
+      lines.push(`  optional methods: ${area.presentOptionalMethodIds.length}/${optionalTotal}`);
+      if (area.missingOptionalMethodIds.length > 0) lines.push(`  missing optional: ${area.missingOptionalMethodIds.join(', ')}`);
+    }
+    for (const route of area.agentRoutes) lines.push(`  route: ${route.route} [${route.coverage}]`);
+    lines.push(`  next: ${area.next.join(' | ')}`);
+    lines.push('');
+  }
+
+  return lines.join('\n').trimEnd();
+}
+
+export function renderDaemonCapabilityFailure(failure: DaemonCapabilityAuditFailure): string {
+  const details = [
+    `GoodVibes daemon capability audit failed [${failure.kind}]`,
+    `  daemon: ${failure.baseUrl}`,
+    `  route: ${failure.route}`,
+    `  error: ${failure.error}`,
+  ];
+  if (failure.daemonVersion || failure.expectedSdkVersion) {
+    details.push(`  SDK: Agent expects ${failure.expectedSdkVersion ?? SDK_VERSION}; daemon reports ${failure.daemonVersion ?? 'unknown'}`);
+  }
+  if (failure.kind === 'auth_required') details.push('  next: authenticate the Agent against the existing GoodVibes daemon; no token value was printed.');
+  if (failure.kind === 'daemon_unavailable') details.push('  next: start or reconnect the external GoodVibes daemon; Agent will not start it.');
+  if (failure.kind === 'version_mismatch') details.push('  next: update/restart the externally owned daemon to match the Agent SDK pin.');
+  if (failure.kind === 'daemon_route_unavailable') details.push('  next: verify the external daemon exposes the published SDK/operator routes.');
+  return details.join('\n');
+}

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