@pellux/goodvibes-agent 0.1.45 → 0.1.47

package/CHANGELOG.md

@@ -2,6 +2,14 @@
 
 All notable changes to GoodVibes Agent will be recorded here.
 
+## 0.1.47 - 2026-05-31
+
+- 2bb2b8a Map daemon methods to Agent UX coverage
+
+## 0.1.46 - 2026-05-31
+
+- e0addfe Add full daemon capability inventory
+
 ## 0.1.45 - 2026-05-31
 
 - 0aa4b3e Add daemon route risk approval review

package/README.md

@@ -19,6 +19,8 @@ goodvibes-agent capabilities
 goodvibes-agent capabilities daemon
 goodvibes-agent capabilities daemon gaps
 goodvibes-agent capabilities daemon risk
+goodvibes-agent capabilities daemon inventory
+goodvibes-agent capabilities daemon coverage
 ```
 
 If Bun reports untrusted lifecycle dependencies, trust only the package and dependencies required by this package:
@@ -47,7 +49,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, live daemon capability coverage, 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 daemon` or `/capabilities daemon` for a live read-only audit of the GoodVibes daemon method catalog, route risk posture, and isolated Agent Knowledge route coverage. Use `goodvibes-agent capabilities daemon gaps` or `/capabilities daemon gaps` to turn that live daemon audit into a prioritized gap plan that separates missing daemon routes from Agent UX work. Use `goodvibes-agent capabilities daemon risk` or `/approval risk` for route-risk-aware approval posture without mutating approval state.
+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, route risk posture, and isolated Agent Knowledge route coverage. Use `goodvibes-agent capabilities daemon inventory` for the full public daemon method inventory grouped by category, access, HTTP posture, and dangerous flags. Use `goodvibes-agent capabilities daemon coverage` to map every daemon method to Agent UX posture: usable, read-only observable, explicit-confirmation, blocked, or not surfaced. Use `goodvibes-agent capabilities daemon gaps` or `/capabilities daemon gaps` to turn that live daemon audit into a prioritized gap plan that separates missing daemon routes from Agent UX work. Use `goodvibes-agent capabilities daemon risk` or `/approval risk` for route-risk-aware approval posture without mutating approval state.
 
 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.
 
@@ -91,9 +93,11 @@ goodvibes-agent capabilities daemon
 goodvibes-agent capabilities daemon --json
 goodvibes-agent capabilities daemon gaps
 goodvibes-agent capabilities daemon risk
+goodvibes-agent capabilities daemon inventory
+goodvibes-agent capabilities daemon coverage
 ```
 
-This audit checks `/api/control-plane/methods` and `/api/goodvibes-agent/knowledge/status`. The gap plan and route-risk review are derived from the same read-only calls. None of these commands query default Knowledge/Wiki or HomeGraph.
+This audit checks `/api/control-plane/methods` and `/api/goodvibes-agent/knowledge/status`. The gap plan, route-risk review, and full method inventory are derived from read-only daemon calls. None of these commands query default Knowledge/Wiki or HomeGraph.
 
 Agent intentionally blocks daemon lifecycle commands:
 

package/docs/operator-capability-benchmark.md

@@ -19,6 +19,8 @@ goodvibes-agent capabilities daemon
 goodvibes-agent capabilities daemon --json
 goodvibes-agent capabilities daemon gaps
 goodvibes-agent capabilities daemon risk
+goodvibes-agent capabilities daemon inventory
+goodvibes-agent capabilities daemon coverage
 goodvibes-agent capabilities daemon knowledge
 ```
 
@@ -30,6 +32,8 @@ Inside the TUI:
 /capabilities knowledge
 /capabilities daemon
 /capabilities daemon gaps
+/capabilities daemon inventory
+/capabilities daemon coverage
 /approval risk
 ```
 
@@ -60,7 +64,7 @@ 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, route risk posture, and the isolated Agent Knowledge status route. Use `goodvibes-agent capabilities daemon gaps` to convert that daemon-measured audit into a prioritized gap plan with `version_mismatch`, `agent_route_missing`, `required_method_missing`, `route_risk_review`, and `agent_ux_gap` rows. Use `goodvibes-agent capabilities daemon risk` or `/approval risk` for a route-risk-aware approval-center view over read-only, mutating, dangerous, and authenticated route metadata. These commands intentionally avoid default `/api/knowledge/*`, HomeGraph, and Home Assistant routes.
+Use `goodvibes-agent capabilities daemon` for the live read-only daemon audit. It checks the public control-plane method catalog, route risk posture, and the isolated Agent Knowledge status route. Use `goodvibes-agent capabilities daemon inventory` for the full public daemon method inventory grouped by category, access, HTTP method, and dangerous flag. Use `goodvibes-agent capabilities daemon coverage` to map every public daemon method to Agent UX posture: usable, read-only observable, explicit-confirmation, blocked by product boundary, or not surfaced yet. Use `goodvibes-agent capabilities daemon gaps` to convert that daemon-measured audit into a prioritized gap plan with `version_mismatch`, `agent_route_missing`, `required_method_missing`, `route_risk_review`, and `agent_ux_gap` rows. Use `goodvibes-agent capabilities daemon risk` or `/approval risk` for a route-risk-aware approval-center view over read-only, mutating, dangerous, and authenticated route metadata. These commands intentionally avoid default `/api/knowledge/*`, HomeGraph, and Home Assistant routes.
 
 ## Capability Targets
 
@@ -82,7 +86,7 @@ Use `goodvibes-agent capabilities daemon` for the live read-only daemon audit. I
 
 GoodVibes Agent should exceed OpenClaw/Hermes by making these properties true from day one:
 
-- Capability surfaces are discoverable through `goodvibes-agent capabilities`, `goodvibes-agent capabilities daemon`, `goodvibes-agent capabilities daemon gaps`, `goodvibes-agent capabilities daemon risk`, `/capabilities`, `/capabilities daemon`, `/approval risk`, onboarding, and the operator workspace.
+- Capability surfaces are discoverable through `goodvibes-agent capabilities`, `goodvibes-agent capabilities daemon`, `goodvibes-agent capabilities daemon inventory`, `goodvibes-agent capabilities daemon coverage`, `goodvibes-agent capabilities daemon gaps`, `goodvibes-agent capabilities daemon risk`, `/capabilities`, `/capabilities daemon`, `/approval risk`, onboarding, and the operator workspace.
 - Agent Knowledge isolation is a release gate, not a convention.
 - Routine-to-schedule promotion preserves Agent Knowledge isolation, uses only public external daemon schedule routes, supports explicit delivery targets, and stores redacted receipts.
 - Model-visible tools are policy-gated for serial, non-secret, non-destructive use.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pellux/goodvibes-agent",
-  "version": "0.1.45",
+  "version": "0.1.47",
   "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

@@ -9,18 +9,24 @@ import {
   buildDaemonCapabilityGapReport,
   buildDaemonCapabilityRouteRiskReport,
   fetchLiveDaemonCapabilityAudit,
+  fetchLiveDaemonCapabilityInventory,
+  fetchLiveDaemonCapabilityUxCoverage,
   filterDaemonCapabilityAuditAreas,
   filterDaemonCapabilityGaps,
+  filterDaemonCapabilityInventoryGroups,
   filterDaemonCapabilityRouteRiskAreas,
+  filterDaemonCapabilityUxGroups,
   renderDaemonCapabilityAudit,
   renderDaemonCapabilityFailure,
   renderDaemonCapabilityGaps,
+  renderDaemonCapabilityInventory,
   renderDaemonCapabilityRouteRisk,
+  renderDaemonCapabilityUxCoverage,
 } from '../operator/daemon-capability-audit.ts';
 import { resolveAgentDaemonConnection } from '../agent/routine-schedule-promotion.ts';
 
 interface CapabilityCommandArgs {
-  readonly mode: 'benchmark' | 'daemon' | 'daemon-gaps' | 'daemon-risk';
+  readonly mode: 'benchmark' | 'daemon' | 'daemon-gaps' | 'daemon-risk' | 'daemon-inventory' | 'daemon-ux';
   readonly query: string | undefined;
 }
 
@@ -39,6 +45,14 @@ function readCapabilityArgs(args: readonly string[]): CapabilityCommandArgs {
       const query = values.slice(2).join(' ').trim();
       return { mode: 'daemon-risk', query: query.length > 0 ? query : undefined };
     }
+    if (values[1] === 'inventory' || values[1] === 'methods' || values[1] === 'routes') {
+      const query = values.slice(2).join(' ').trim();
+      return { mode: 'daemon-inventory', query: query.length > 0 ? query : undefined };
+    }
+    if (values[1] === 'coverage' || values[1] === 'ux' || values[1] === 'surface') {
+      const query = values.slice(2).join(' ').trim();
+      return { mode: 'daemon-ux', query: query.length > 0 ? query : undefined };
+    }
     const query = values.slice(1).join(' ').trim();
     return { mode: 'daemon', query: query.length > 0 ? query : undefined };
   }
@@ -106,6 +120,44 @@ export async function handleCapabilitiesCommand(runtime: CliCommandRuntime): Pro
       exitCode: 0,
     };
   }
+  if (args.mode === 'daemon-inventory') {
+    const connection = resolveAgentDaemonConnection(runtime.configManager, runtime.homeDirectory);
+    const inventory = await fetchLiveDaemonCapabilityInventory(connection);
+    if (!inventory.ok) {
+      return {
+        output: runtime.cli.flags.outputFormat === 'json'
+          ? JSON.stringify(inventory, null, 2)
+          : renderDaemonCapabilityFailure(inventory),
+        exitCode: inventory.kind === 'auth_required' || inventory.kind === 'daemon_unavailable' ? 1 : 2,
+      };
+    }
+    const groups = filterDaemonCapabilityInventoryGroups(inventory.groups, args.query);
+    return {
+      output: runtime.cli.flags.outputFormat === 'json'
+        ? JSON.stringify({ ...inventory, matchedGroupCount: groups.length, groups }, null, 2)
+        : renderDaemonCapabilityInventory(inventory, groups),
+      exitCode: 0,
+    };
+  }
+  if (args.mode === 'daemon-ux') {
+    const connection = resolveAgentDaemonConnection(runtime.configManager, runtime.homeDirectory);
+    const coverage = await fetchLiveDaemonCapabilityUxCoverage(connection);
+    if (!coverage.ok) {
+      return {
+        output: runtime.cli.flags.outputFormat === 'json'
+          ? JSON.stringify(coverage, null, 2)
+          : renderDaemonCapabilityFailure(coverage),
+        exitCode: coverage.kind === 'auth_required' || coverage.kind === 'daemon_unavailable' ? 1 : 2,
+      };
+    }
+    const groups = filterDaemonCapabilityUxGroups(coverage.groups, args.query);
+    return {
+      output: runtime.cli.flags.outputFormat === 'json'
+        ? JSON.stringify({ ...coverage, matchedGroupCount: groups.length, groups }, null, 2)
+        : renderDaemonCapabilityUxCoverage(coverage, groups),
+      exitCode: 0,
+    };
+  }
   const report = buildOperatorCapabilityBenchmarkReport();
   const capabilities = filterOperatorCapabilities(report.capabilities, args.query);
   if (runtime.cli.flags.outputFormat === 'json') {

package/src/cli/help.ts

@@ -105,6 +105,8 @@ export function renderGoodVibesHelp(binary = 'goodvibes-agent'): string {
     `  ${binary} capabilities daemon`,
     `  ${binary} capabilities daemon gaps`,
     `  ${binary} capabilities daemon risk`,
+    `  ${binary} capabilities daemon inventory`,
+    `  ${binary} capabilities daemon coverage`,
     `  ${binary} knowledge status`,
     `  ${binary} knowledge ask "What is GoodVibes Agent?"`,
     `  ${binary} ask "What is GoodVibes Agent?"`,
@@ -199,9 +201,9 @@ const COMMAND_HELP: Record<string, CommandHelp> = {
     examples: ['compat', 'compat --json'],
   },
   capabilities: {
-    usage: ['capabilities [openclaw|hermes|query]', 'capabilities daemon [query]', 'capabilities daemon gaps [query]', 'capabilities daemon risk [query]', 'capabilities --json'],
-    summary: 'Show the OpenClaw/Hermes capability benchmark, Agent readiness, live GoodVibes daemon method coverage, and daemon-measured product gaps.',
-    examples: ['capabilities', 'capabilities hermes', 'capabilities daemon', 'capabilities daemon gaps', 'capabilities daemon risk --json', 'capabilities daemon knowledge --json'],
+    usage: ['capabilities [openclaw|hermes|query]', 'capabilities daemon [query]', 'capabilities daemon gaps [query]', 'capabilities daemon risk [query]', 'capabilities daemon inventory [query]', 'capabilities daemon coverage [query]', 'capabilities --json'],
+    summary: 'Show the OpenClaw/Hermes capability benchmark, Agent readiness, live GoodVibes daemon method coverage, route risk, and daemon-measured product gaps.',
+    examples: ['capabilities', 'capabilities hermes', 'capabilities daemon', 'capabilities daemon gaps', 'capabilities daemon risk --json', 'capabilities daemon inventory channels --json', 'capabilities daemon coverage not_surfaced'],
   },
   knowledge: {
     usage: [

package/src/input/agent-workspace.ts

@@ -491,6 +491,8 @@ export const AGENT_WORKSPACE_CATEGORIES: readonly AgentWorkspaceCategory[] = [
       { id: 'capabilities-daemon', label: 'Live daemon audit', detail: 'Inspect the public daemon method catalog plus isolated Agent Knowledge route coverage. Does not query default Knowledge/Wiki or HomeGraph.', command: '/capabilities daemon', kind: 'command', safety: 'read-only' },
       { id: 'capabilities-daemon-gaps', label: 'Daemon gap plan', detail: 'Classify live daemon coverage into platform gaps, Agent route gaps, route-risk reviews, and Agent UX work without querying default Knowledge/Wiki or HomeGraph.', command: '/capabilities daemon gaps', kind: 'command', safety: 'read-only' },
       { id: 'capabilities-daemon-risk', label: 'Route risk review', detail: 'Inspect daemon read-only, mutating, dangerous, and authenticated route metadata for approval-center planning.', command: '/capabilities daemon risk', kind: 'command', safety: 'read-only' },
+      { id: 'capabilities-daemon-inventory', label: 'Full method inventory', detail: 'List every public daemon method by category, HTTP posture, access, and dangerous flag without querying default Knowledge/Wiki or HomeGraph.', command: '/capabilities daemon inventory', kind: 'command', safety: 'read-only' },
+      { id: 'capabilities-daemon-coverage', label: 'UX coverage matrix', detail: 'Map every public daemon method to Agent UX coverage: usable, read-only, explicit confirmation, blocked, or not surfaced.', command: '/capabilities daemon coverage', kind: 'command', safety: 'read-only' },
       { id: 'capabilities-daemon-knowledge', label: 'Knowledge coverage', detail: 'Filter the live daemon audit to the isolated Agent Knowledge segment.', command: '/capabilities daemon knowledge', kind: 'command', safety: 'read-only' },
       { id: 'capabilities-daemon-channels', label: 'Channel coverage', detail: 'Filter the live daemon audit to channel and delivery gateway route coverage.', command: '/capabilities daemon channels', kind: 'command', safety: 'read-only' },
       { id: 'capabilities-daemon-automation', label: 'Automation coverage', detail: 'Filter the live daemon audit to automation, schedule, run, and capacity route coverage.', command: '/capabilities daemon automation', kind: 'command', safety: 'read-only' },

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

@@ -8,13 +8,19 @@ import {
   buildDaemonCapabilityGapReport,
   buildDaemonCapabilityRouteRiskReport,
   fetchLiveDaemonCapabilityAudit,
+  fetchLiveDaemonCapabilityInventory,
+  fetchLiveDaemonCapabilityUxCoverage,
   filterDaemonCapabilityAuditAreas,
   filterDaemonCapabilityGaps,
+  filterDaemonCapabilityInventoryGroups,
   filterDaemonCapabilityRouteRiskAreas,
+  filterDaemonCapabilityUxGroups,
   renderDaemonCapabilityAudit,
   renderDaemonCapabilityFailure,
   renderDaemonCapabilityGaps,
+  renderDaemonCapabilityInventory,
   renderDaemonCapabilityRouteRisk,
+  renderDaemonCapabilityUxCoverage,
 } from '../../operator/daemon-capability-audit.ts';
 import { resolveAgentDaemonConnection } from '../../agent/routine-schedule-promotion.ts';
 
@@ -47,6 +53,28 @@ export function registerCapabilitiesRuntimeCommands(registry: CommandRegistry):
           ctx.print(renderDaemonCapabilityRouteRisk(report, areas));
           return;
         }
+        if (args[1] === 'inventory' || args[1] === 'methods' || args[1] === 'routes') {
+          const inventory = await fetchLiveDaemonCapabilityInventory(connection);
+          if (!inventory.ok) {
+            ctx.print(renderDaemonCapabilityFailure(inventory));
+            return;
+          }
+          const query = args.slice(2).join(' ').trim() || undefined;
+          const groups = filterDaemonCapabilityInventoryGroups(inventory.groups, query);
+          ctx.print(renderDaemonCapabilityInventory(inventory, groups));
+          return;
+        }
+        if (args[1] === 'coverage' || args[1] === 'ux' || args[1] === 'surface') {
+          const coverage = await fetchLiveDaemonCapabilityUxCoverage(connection);
+          if (!coverage.ok) {
+            ctx.print(renderDaemonCapabilityFailure(coverage));
+            return;
+          }
+          const query = args.slice(2).join(' ').trim() || undefined;
+          const groups = filterDaemonCapabilityUxGroups(coverage.groups, query);
+          ctx.print(renderDaemonCapabilityUxCoverage(coverage, groups));
+          return;
+        }
         const query = args.slice(1).join(' ').trim() || undefined;
         const areas = filterDaemonCapabilityAuditAreas(audit.areas, query);
         ctx.print(renderDaemonCapabilityAudit(audit, areas));

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

@@ -135,6 +135,107 @@ export interface DaemonCapabilityRouteRiskReport {
   readonly areas: readonly DaemonCapabilityRouteRiskArea[];
 }
 
+export interface DaemonCapabilityInventoryMethod {
+  readonly id: string;
+  readonly title?: string;
+  readonly category: string;
+  readonly access: string;
+  readonly invokable: boolean | null;
+  readonly dangerous: boolean;
+  readonly httpMethod: string;
+  readonly path?: string;
+  readonly readOnly: boolean;
+  readonly mutating: boolean;
+}
+
+export interface DaemonCapabilityInventoryGroup {
+  readonly category: string;
+  readonly methodCount: number;
+  readonly readOnlyMethodCount: number;
+  readonly mutatingMethodCount: number;
+  readonly authenticatedMethodCount: number;
+  readonly dangerousMethodCount: number;
+  readonly methods: readonly DaemonCapabilityInventoryMethod[];
+}
+
+export interface DaemonCapabilityInventoryReport {
+  readonly ok: true;
+  readonly kind: 'daemon.capabilities.inventory';
+  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 readOnlyMethodCount: number;
+  readonly mutatingMethodCount: number;
+  readonly authenticatedMethodCount: number;
+  readonly dangerousMethodCount: number;
+  readonly accessCounts: readonly {
+    readonly access: string;
+    readonly count: number;
+  }[];
+  readonly groups: readonly DaemonCapabilityInventoryGroup[];
+}
+
+export type DaemonCapabilityUxCoverage =
+  | 'usable'
+  | 'read_only'
+  | 'explicit_confirmation'
+  | 'blocked'
+  | 'not_surfaced';
+
+export interface DaemonCapabilityUxMethod {
+  readonly id: string;
+  readonly title?: string;
+  readonly category: string;
+  readonly access: string;
+  readonly httpMethod: string;
+  readonly path?: string;
+  readonly dangerous: boolean;
+  readonly readOnly: boolean;
+  readonly mutating: boolean;
+  readonly uxCoverage: DaemonCapabilityUxCoverage;
+  readonly surface: string;
+  readonly next: string;
+}
+
+export interface DaemonCapabilityUxGroup {
+  readonly category: string;
+  readonly methodCount: number;
+  readonly usableMethodCount: number;
+  readonly readOnlyMethodCount: number;
+  readonly explicitConfirmationMethodCount: number;
+  readonly blockedMethodCount: number;
+  readonly notSurfacedMethodCount: number;
+  readonly methods: readonly DaemonCapabilityUxMethod[];
+}
+
+export interface DaemonCapabilityUxCoverageReport {
+  readonly ok: true;
+  readonly kind: 'daemon.capabilities.ux_coverage';
+  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 usableMethodCount: number;
+  readonly readOnlyMethodCount: number;
+  readonly explicitConfirmationMethodCount: number;
+  readonly blockedMethodCount: number;
+  readonly notSurfacedMethodCount: number;
+  readonly groups: readonly DaemonCapabilityUxGroup[];
+}
+
 export interface DaemonCapabilityAuditFailure {
   readonly ok: false;
   readonly kind: DaemonCapabilityAuditFailureKind;
@@ -380,6 +481,197 @@ function readMethodSummaries(body: unknown): readonly DaemonMethodSummary[] {
   });
 }
 
+function normalizeMethodCategory(method: DaemonMethodSummary): string {
+  const category = method.category?.trim();
+  if (category) return category;
+  const [prefix] = method.id.split('.');
+  return prefix || 'uncategorized';
+}
+
+function normalizeAccess(method: DaemonMethodSummary): string {
+  const access = method.access?.trim();
+  return access || 'unknown';
+}
+
+function normalizeHttpMethod(method: DaemonMethodSummary): string {
+  return method.http?.method?.trim().toUpperCase() || 'UNKNOWN';
+}
+
+function isReadOnlyHttpMethod(httpMethod: string): boolean {
+  return httpMethod === 'GET' || httpMethod === 'HEAD';
+}
+
+function compareInventoryMethods(left: DaemonCapabilityInventoryMethod, right: DaemonCapabilityInventoryMethod): number {
+  return left.id.localeCompare(right.id);
+}
+
+function compareInventoryGroups(left: DaemonCapabilityInventoryGroup, right: DaemonCapabilityInventoryGroup): number {
+  const countDelta = right.methodCount - left.methodCount;
+  if (countDelta !== 0) return countDelta;
+  return left.category.localeCompare(right.category);
+}
+
+function compareUxGroups(left: DaemonCapabilityUxGroup, right: DaemonCapabilityUxGroup): number {
+  const gapDelta = right.notSurfacedMethodCount + right.blockedMethodCount
+    - (left.notSurfacedMethodCount + left.blockedMethodCount);
+  if (gapDelta !== 0) return gapDelta;
+  const countDelta = right.methodCount - left.methodCount;
+  if (countDelta !== 0) return countDelta;
+  return left.category.localeCompare(right.category);
+}
+
+const USABLE_METHOD_SURFACES = new Map<string, string>([
+  ['control.status', 'status / smoke / compat'],
+  ['control.auth.current', 'auth / status / smoke'],
+  ['control.methods.list', 'capabilities daemon inventory / coverage / risk'],
+  ['control.contract', 'compat / capability checks'],
+  ['control.snapshot', 'status / capability checks'],
+  ['companion.chat.sessions.create', 'chat session management'],
+  ['companion.chat.sessions.get', 'chat session management'],
+  ['companion.chat.sessions.list', 'chat session management'],
+  ['companion.chat.sessions.update', 'chat session management'],
+  ['companion.chat.messages.create', 'normal assistant chat'],
+  ['companion.chat.messages.list', 'normal assistant chat'],
+  ['sessions.messages.create', 'explicit build delegation to GoodVibes TUI'],
+  ['sessions.list', 'delegations status'],
+  ['tasks.list', 'delegations status'],
+  ['projectPlanning.workPlan.snapshot', 'workplan'],
+  ['approvals.list', 'approvals / approval risk'],
+  ['automation.integration.snapshot', 'automation status'],
+  ['automation.jobs.list', 'automation jobs'],
+  ['automation.runs.list', 'automation runs'],
+  ['automation.heartbeat.list', 'automation heartbeat'],
+  ['schedules.list', 'schedules'],
+  ['scheduler.capacity', 'automation capacity'],
+  ['providers.list', 'provider/model setup'],
+  ['providers.get', 'provider/model setup'],
+  ['providers.usage.get', 'provider usage'],
+  ['accounts.snapshot', 'provider account posture'],
+  ['channels.status', 'channel onboarding/status'],
+  ['channels.capabilities.list', 'channel onboarding/status'],
+  ['channels.accounts.list', 'channel onboarding/status'],
+  ['channels.setup.get', 'channel onboarding/status'],
+  ['channels.doctor.get', 'channel diagnostics'],
+  ['channels.actions.list', 'channel capabilities'],
+  ['channels.tools.list', 'channel capabilities'],
+  ['channels.targets.resolve', 'routine delivery planning'],
+  ['channels.policies.list', 'channel safety posture'],
+  ['mcp.config.get', 'MCP setup/status'],
+  ['mcp.servers.list', 'MCP setup/status'],
+  ['mcp.tools.list', 'MCP setup/status'],
+  ['web_search.providers.list', 'research/tool readiness'],
+  ['web_search.query', 'research/tool readiness'],
+  ['voice.status', 'voice setup/status'],
+  ['voice.providers.list', 'voice setup/status'],
+  ['voice.voices.list', 'voice setup/status'],
+  ['media.providers.list', 'media setup/status'],
+  ['multimodal.providers.list', 'multimodal setup/status'],
+  ['remote.snapshot', 'remote/node setup'],
+  ['remote.peers.list', 'remote/node setup'],
+  ['remote.work.list', 'remote work status'],
+  ['remote.node_host.contract', 'remote/node setup'],
+]);
+
+const EXPLICIT_CONFIRMATION_METHOD_SURFACES = new Map<string, string>([
+  ['approvals.approve', 'approvals approve --yes'],
+  ['approvals.deny', 'approvals deny --yes'],
+  ['approvals.cancel', 'approvals cancel --yes'],
+  ['automation.jobs.run', 'automation jobs run --yes'],
+  ['automation.jobs.pause', 'automation jobs pause --yes'],
+  ['automation.jobs.resume', 'automation jobs resume --yes'],
+  ['automation.runs.cancel', 'automation runs cancel --yes'],
+  ['automation.runs.retry', 'automation runs retry --yes'],
+  ['schedules.run', 'schedules run --yes'],
+]);
+
+const READ_ONLY_CATEGORY_SURFACES = new Map<string, string>([
+  ['approvals', 'approvals / approval risk'],
+  ['artifacts', 'artifact-aware chat and receipts'],
+  ['automation', 'automation status'],
+  ['channels', 'channel onboarding/status'],
+  ['companion', 'chat session management'],
+  ['control', 'status / capabilities'],
+  ['mcp', 'MCP setup/status'],
+  ['media', 'media setup/status'],
+  ['multimodal', 'multimodal setup/status'],
+  ['projectPlanning', 'workplan'],
+  ['providers', 'provider/model setup'],
+  ['remote', 'remote/node setup'],
+  ['schedules', 'schedules'],
+  ['scheduler', 'automation capacity'],
+  ['sessions', 'delegations status'],
+  ['tasks', 'delegations status'],
+  ['voice', 'voice setup/status'],
+  ['web_search', 'research/tool readiness'],
+]);
+
+function isDefaultKnowledgeMethod(method: DaemonCapabilityInventoryMethod): boolean {
+  return method.id.startsWith('knowledge.');
+}
+
+function isHomeGraphMethod(method: DaemonCapabilityInventoryMethod): boolean {
+  return method.id.startsWith('homeassistant.') || method.id.toLowerCase().includes('homegraph');
+}
+
+function classifyDaemonMethodUx(method: DaemonCapabilityInventoryMethod): DaemonCapabilityUxMethod {
+  const explicitSurface = EXPLICIT_CONFIRMATION_METHOD_SURFACES.get(method.id);
+  if (explicitSurface) {
+    return {
+      ...method,
+      uxCoverage: 'explicit_confirmation',
+      surface: explicitSurface,
+      next: 'Already exposed only through exact user commands plus confirmation.',
+    };
+  }
+
+  const usableSurface = USABLE_METHOD_SURFACES.get(method.id);
+  if (usableSurface) {
+    return {
+      ...method,
+      uxCoverage: 'usable',
+      surface: usableSurface,
+      next: 'Keep this route covered by command/help/workspace smoke as the daemon contract evolves.',
+    };
+  }
+
+  if (isDefaultKnowledgeMethod(method)) {
+    return {
+      ...method,
+      uxCoverage: 'blocked',
+      surface: 'blocked for Agent Knowledge',
+      next: 'Do not use default Knowledge/Wiki as an Agent fallback; use /api/goodvibes-agent/knowledge/* only.',
+    };
+  }
+
+  if (isHomeGraphMethod(method)) {
+    return {
+      ...method,
+      uxCoverage: 'blocked',
+      surface: 'blocked for Agent product boundary',
+      next: 'Do not use HomeGraph or Home Assistant routes as Agent Knowledge fallback.',
+    };
+  }
+
+  const readOnlySurface = READ_ONLY_CATEGORY_SURFACES.get(method.category);
+  if (method.readOnly && readOnlySurface) {
+    return {
+      ...method,
+      uxCoverage: 'read_only',
+      surface: readOnlySurface,
+      next: 'Visible through read-only posture, inventory, or status surfaces; add focused UX if this becomes user-facing.',
+    };
+  }
+
+  return {
+    ...method,
+    uxCoverage: 'not_surfaced',
+    surface: 'daemon inventory only',
+    next: method.mutating || method.dangerous
+      ? 'Design an exact command, approval posture, and confirmation flow before exposing this side effect.'
+      : 'Add a focused Agent command or workspace card if this daemon capability is part of the product surface.',
+  };
+}
+
 function daemonVersionFromStatus(body: unknown): string {
   if (!isRecord(body)) return 'unknown';
   return readString(body, 'version')
@@ -585,6 +877,207 @@ export async function fetchLiveDaemonCapabilityAudit(
   }
 }
 
+export function buildDaemonCapabilityInventoryReport(
+  connection: AgentDaemonConnection,
+  daemonVersion: string,
+  agentKnowledgeRouteReady: boolean,
+  methodSummaries: readonly DaemonMethodSummary[],
+): DaemonCapabilityInventoryReport {
+  const methods = methodSummaries.map((method): DaemonCapabilityInventoryMethod => {
+    const httpMethod = normalizeHttpMethod(method);
+    const readOnly = isReadOnlyHttpMethod(httpMethod);
+    return {
+      id: method.id,
+      title: method.title,
+      category: normalizeMethodCategory(method),
+      access: normalizeAccess(method),
+      invokable: typeof method.invokable === 'boolean' ? method.invokable : null,
+      dangerous: method.dangerous === true,
+      httpMethod,
+      path: method.http?.path,
+      readOnly,
+      mutating: httpMethod !== 'UNKNOWN' && !readOnly,
+    };
+  }).sort(compareInventoryMethods);
+
+  const groupsByCategory = new Map<string, DaemonCapabilityInventoryMethod[]>();
+  for (const method of methods) {
+    const existing = groupsByCategory.get(method.category) ?? [];
+    existing.push(method);
+    groupsByCategory.set(method.category, existing);
+  }
+
+  const groups = [...groupsByCategory.entries()].map(([category, categoryMethods]): DaemonCapabilityInventoryGroup => ({
+    category,
+    methodCount: categoryMethods.length,
+    readOnlyMethodCount: categoryMethods.filter((method) => method.readOnly).length,
+    mutatingMethodCount: categoryMethods.filter((method) => method.mutating).length,
+    authenticatedMethodCount: categoryMethods.filter((method) => method.access === 'authenticated').length,
+    dangerousMethodCount: categoryMethods.filter((method) => method.dangerous).length,
+    methods: categoryMethods,
+  })).sort(compareInventoryGroups);
+
+  const accessEntries = new Map<string, number>();
+  for (const method of methods) {
+    accessEntries.set(method.access, (accessEntries.get(method.access) ?? 0) + 1);
+  }
+  const accessCounts = [...accessEntries.entries()]
+    .map(([access, count]) => ({ access, count }))
+    .sort((left, right) => {
+      const countDelta = right.count - left.count;
+      if (countDelta !== 0) return countDelta;
+      return left.access.localeCompare(right.access);
+    });
+
+  return {
+    ok: true,
+    kind: 'daemon.capabilities.inventory',
+    baseUrl: connection.baseUrl,
+    daemonVersion,
+    expectedSdkVersion: SDK_VERSION,
+    daemonCompatible: daemonVersion === SDK_VERSION,
+    methodCatalogRoute: DAEMON_METHOD_CATALOG_ROUTE,
+    methodCount: methods.length,
+    agentKnowledgeRoute: AGENT_KNOWLEDGE_STATUS_ROUTE,
+    agentKnowledgeRouteReady,
+    defaultKnowledgeFallback: false,
+    homeGraphFallback: false,
+    readOnlyMethodCount: methods.filter((method) => method.readOnly).length,
+    mutatingMethodCount: methods.filter((method) => method.mutating).length,
+    authenticatedMethodCount: methods.filter((method) => method.access === 'authenticated').length,
+    dangerousMethodCount: methods.filter((method) => method.dangerous).length,
+    accessCounts,
+    groups,
+  };
+}
+
+export type DaemonCapabilityInventoryResult =
+  | DaemonCapabilityInventoryReport
+  | DaemonCapabilityAuditFailure;
+
+export type DaemonCapabilityUxCoverageResult =
+  | DaemonCapabilityUxCoverageReport
+  | DaemonCapabilityAuditFailure;
+
+export function buildDaemonCapabilityUxCoverageReport(
+  inventory: DaemonCapabilityInventoryReport,
+): DaemonCapabilityUxCoverageReport {
+  const methods = inventory.groups
+    .flatMap((group) => group.methods)
+    .map(classifyDaemonMethodUx);
+
+  const groupsByCategory = new Map<string, DaemonCapabilityUxMethod[]>();
+  for (const method of methods) {
+    const existing = groupsByCategory.get(method.category) ?? [];
+    existing.push(method);
+    groupsByCategory.set(method.category, existing);
+  }
+
+  const groups = [...groupsByCategory.entries()].map(([category, categoryMethods]): DaemonCapabilityUxGroup => ({
+    category,
+    methodCount: categoryMethods.length,
+    usableMethodCount: categoryMethods.filter((method) => method.uxCoverage === 'usable').length,
+    readOnlyMethodCount: categoryMethods.filter((method) => method.uxCoverage === 'read_only').length,
+    explicitConfirmationMethodCount: categoryMethods.filter((method) => method.uxCoverage === 'explicit_confirmation').length,
+    blockedMethodCount: categoryMethods.filter((method) => method.uxCoverage === 'blocked').length,
+    notSurfacedMethodCount: categoryMethods.filter((method) => method.uxCoverage === 'not_surfaced').length,
+    methods: categoryMethods,
+  })).sort(compareUxGroups);
+
+  return {
+    ok: true,
+    kind: 'daemon.capabilities.ux_coverage',
+    baseUrl: inventory.baseUrl,
+    daemonVersion: inventory.daemonVersion,
+    expectedSdkVersion: inventory.expectedSdkVersion,
+    daemonCompatible: inventory.daemonCompatible,
+    methodCatalogRoute: inventory.methodCatalogRoute,
+    methodCount: inventory.methodCount,
+    agentKnowledgeRoute: inventory.agentKnowledgeRoute,
+    agentKnowledgeRouteReady: inventory.agentKnowledgeRouteReady,
+    defaultKnowledgeFallback: false,
+    homeGraphFallback: false,
+    usableMethodCount: methods.filter((method) => method.uxCoverage === 'usable').length,
+    readOnlyMethodCount: methods.filter((method) => method.uxCoverage === 'read_only').length,
+    explicitConfirmationMethodCount: methods.filter((method) => method.uxCoverage === 'explicit_confirmation').length,
+    blockedMethodCount: methods.filter((method) => method.uxCoverage === 'blocked').length,
+    notSurfacedMethodCount: methods.filter((method) => method.uxCoverage === 'not_surfaced').length,
+    groups,
+  };
+}
+
+export function filterDaemonCapabilityUxGroups(
+  groups: readonly DaemonCapabilityUxGroup[],
+  query: string | undefined,
+): readonly DaemonCapabilityUxGroup[] {
+  const normalized = query?.trim().toLowerCase();
+  if (!normalized) return groups;
+  return groups.flatMap((group): DaemonCapabilityUxGroup[] => {
+    const categoryMatches = group.category.toLowerCase().includes(normalized);
+    const methods = categoryMatches
+      ? group.methods
+      : group.methods.filter((method) => {
+          return method.id.toLowerCase().includes(normalized)
+            || method.title?.toLowerCase().includes(normalized) === true
+            || method.uxCoverage.includes(normalized)
+            || method.surface.toLowerCase().includes(normalized)
+            || method.next.toLowerCase().includes(normalized)
+            || method.path?.toLowerCase().includes(normalized) === true;
+        });
+    if (methods.length === 0) return [];
+    return [{
+      category: group.category,
+      methodCount: methods.length,
+      usableMethodCount: methods.filter((method) => method.uxCoverage === 'usable').length,
+      readOnlyMethodCount: methods.filter((method) => method.uxCoverage === 'read_only').length,
+      explicitConfirmationMethodCount: methods.filter((method) => method.uxCoverage === 'explicit_confirmation').length,
+      blockedMethodCount: methods.filter((method) => method.uxCoverage === 'blocked').length,
+      notSurfacedMethodCount: methods.filter((method) => method.uxCoverage === 'not_surfaced').length,
+      methods,
+    }];
+  });
+}
+
+export async function fetchLiveDaemonCapabilityUxCoverage(
+  connection: AgentDaemonConnection,
+): Promise<DaemonCapabilityUxCoverageResult> {
+  const inventory = await fetchLiveDaemonCapabilityInventory(connection);
+  if (!inventory.ok) return inventory;
+  return buildDaemonCapabilityUxCoverageReport(inventory);
+}
+
+export async function fetchLiveDaemonCapabilityInventory(
+  connection: AgentDaemonConnection,
+): Promise<DaemonCapabilityInventoryResult> {
+  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 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;
+    }
+
+    return buildDaemonCapabilityInventoryReport(
+      connection,
+      daemonVersion,
+      agentKnowledge.ok,
+      readMethodSummaries(methods.body),
+    );
+  } catch (error) {
+    return failureFromThrown(error, connection, daemonVersion === 'unknown' ? DAEMON_STATUS_ROUTE : DAEMON_METHOD_CATALOG_ROUTE);
+  }
+}
+
 export function filterDaemonCapabilityAuditAreas(
   areas: readonly DaemonCapabilityAuditArea[],
   query: string | undefined,
@@ -857,6 +1350,130 @@ export function renderDaemonCapabilityRouteRisk(
   return lines.join('\n').trimEnd();
 }
 
+export function filterDaemonCapabilityInventoryGroups(
+  groups: readonly DaemonCapabilityInventoryGroup[],
+  query: string | undefined,
+): readonly DaemonCapabilityInventoryGroup[] {
+  const normalized = query?.trim().toLowerCase();
+  if (!normalized) return groups;
+  return groups.flatMap((group): DaemonCapabilityInventoryGroup[] => {
+    const categoryMatches = group.category.toLowerCase().includes(normalized);
+    const methods = categoryMatches
+      ? group.methods
+      : group.methods.filter((method) => {
+          return method.id.toLowerCase().includes(normalized)
+            || method.title?.toLowerCase().includes(normalized) === true
+            || method.access.toLowerCase().includes(normalized)
+            || method.httpMethod.toLowerCase().includes(normalized)
+            || method.path?.toLowerCase().includes(normalized) === true;
+        });
+    if (methods.length === 0) return [];
+    return [{
+      category: group.category,
+      methodCount: methods.length,
+      readOnlyMethodCount: methods.filter((method) => method.readOnly).length,
+      mutatingMethodCount: methods.filter((method) => method.mutating).length,
+      authenticatedMethodCount: methods.filter((method) => method.access === 'authenticated').length,
+      dangerousMethodCount: methods.filter((method) => method.dangerous).length,
+      methods,
+    }];
+  });
+}
+
+function renderInventoryMethod(method: DaemonCapabilityInventoryMethod): string {
+  const risk = method.dangerous
+    ? ' dangerous'
+    : method.mutating
+      ? ' mutating'
+      : ' read-only';
+  const route = method.path ? ` ${method.httpMethod} ${method.path}` : ` ${method.httpMethod}`;
+  return `    ${method.id} [${method.access};${risk}]${route}`;
+}
+
+export function renderDaemonCapabilityInventory(
+  report: DaemonCapabilityInventoryReport,
+  groups: readonly DaemonCapabilityInventoryGroup[] = report.groups,
+): string {
+  const lines: string[] = [
+    'GoodVibes daemon method inventory',
+    `  daemon: ${report.baseUrl}`,
+    `  SDK: Agent expects ${report.expectedSdkVersion}; daemon reports ${report.daemonVersion}`,
+    `  compatibility: ${report.daemonCompatible ? 'matched' : 'mismatch'}`,
+    `  method catalog: ${report.methodCount} methods from ${report.methodCatalogRoute}`,
+    `  Agent Knowledge: ${report.agentKnowledgeRouteReady ? 'ready' : 'missing'} ${report.agentKnowledgeRoute}`,
+    '  isolation: default Knowledge/Wiki fallback no; HomeGraph fallback no',
+    `  totals: ${report.readOnlyMethodCount} read-only; ${report.mutatingMethodCount} mutating; ${report.dangerousMethodCount} dangerous; ${report.authenticatedMethodCount} authenticated`,
+    `  access: ${report.accessCounts.map((entry) => `${entry.access} ${entry.count}`).join('; ') || 'none'}`,
+    '',
+  ];
+
+  if (groups.length === 0) {
+    lines.push('No daemon methods matched this query.');
+    return lines.join('\n');
+  }
+
+  for (const group of groups) {
+    lines.push(`${group.category} (${group.methodCount})`);
+    lines.push(`  ${group.readOnlyMethodCount} read-only; ${group.mutatingMethodCount} mutating; ${group.dangerousMethodCount} dangerous; ${group.authenticatedMethodCount} authenticated`);
+    const visibleMethods = group.methods.slice(0, 12);
+    for (const method of visibleMethods) lines.push(renderInventoryMethod(method));
+    if (group.methods.length > visibleMethods.length) {
+      lines.push(`    ... ${group.methods.length - visibleMethods.length} more; use --json or a narrower query for the full list.`);
+    }
+    lines.push('');
+  }
+
+  return lines.join('\n').trimEnd();
+}
+
+function renderUxMethod(method: DaemonCapabilityUxMethod): string {
+  const route = method.path ? ` ${method.httpMethod} ${method.path}` : ` ${method.httpMethod}`;
+  return `    ${method.id} [${method.uxCoverage}]${route} -> ${method.surface}`;
+}
+
+export function renderDaemonCapabilityUxCoverage(
+  report: DaemonCapabilityUxCoverageReport,
+  groups: readonly DaemonCapabilityUxGroup[] = report.groups,
+): string {
+  const lines: string[] = [
+    'GoodVibes daemon-to-Agent UX coverage',
+    `  daemon: ${report.baseUrl}`,
+    `  SDK: Agent expects ${report.expectedSdkVersion}; daemon reports ${report.daemonVersion}`,
+    `  compatibility: ${report.daemonCompatible ? 'matched' : 'mismatch'}`,
+    `  method catalog: ${report.methodCount} methods from ${report.methodCatalogRoute}`,
+    `  Agent Knowledge: ${report.agentKnowledgeRouteReady ? 'ready' : 'missing'} ${report.agentKnowledgeRoute}`,
+    '  isolation: default Knowledge/Wiki fallback no; HomeGraph fallback no',
+    `  totals: ${report.usableMethodCount} usable; ${report.readOnlyMethodCount} read-only observable; ${report.explicitConfirmationMethodCount} explicit-confirmation; ${report.blockedMethodCount} blocked; ${report.notSurfacedMethodCount} not surfaced`,
+    '',
+  ];
+
+  if (groups.length === 0) {
+    lines.push('No daemon UX coverage rows matched this query.');
+    return lines.join('\n');
+  }
+
+  for (const group of groups) {
+    lines.push(`${group.category} (${group.methodCount})`);
+    lines.push(`  ${group.usableMethodCount} usable; ${group.readOnlyMethodCount} read-only; ${group.explicitConfirmationMethodCount} explicit-confirmation; ${group.blockedMethodCount} blocked; ${group.notSurfacedMethodCount} not surfaced`);
+    const priorityMethods = group.methods
+      .filter((method) => method.uxCoverage === 'not_surfaced' || method.uxCoverage === 'blocked')
+      .slice(0, 12);
+    const visibleMethods = priorityMethods.length > 0 ? priorityMethods : group.methods.slice(0, 12);
+    for (const method of visibleMethods) {
+      lines.push(renderUxMethod(method));
+      if (method.uxCoverage === 'not_surfaced' || method.uxCoverage === 'blocked') {
+        lines.push(`      next: ${method.next}`);
+      }
+    }
+    if (group.methods.length > visibleMethods.length) {
+      lines.push(`    ... ${group.methods.length - visibleMethods.length} more; use --json or a narrower query for the full list.`);
+    }
+    lines.push('');
+  }
+
+  return lines.join('\n').trimEnd();
+}
+
 export function renderDaemonCapabilityAudit(
   audit: DaemonCapabilityAuditSuccess,
   areas: readonly DaemonCapabilityAuditArea[] = audit.areas,

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