@pellux/goodvibes-agent 1.0.2 → 1.0.4

package/src/tools/agent-harness-model-tool-catalog.ts

@@ -0,0 +1,36 @@
+import type { ToolRegistry } from '@pellux/goodvibes-sdk/platform/tools';
+
+export interface AgentHarnessModelToolCatalogArgs {
+  readonly query?: unknown;
+  readonly includeParameters?: unknown;
+  readonly limit?: unknown;
+}
+
+function readString(value: unknown): string {
+  return typeof value === 'string' ? value.trim() : '';
+}
+
+function readLimit(value: unknown, fallback: number): number {
+  const parsed = typeof value === 'string' && value.trim() ? Number(value) : value;
+  if (typeof parsed !== 'number' || !Number.isFinite(parsed)) return fallback;
+  return Math.max(1, Math.min(500, Math.trunc(parsed)));
+}
+
+export function listHarnessModelTools(toolRegistry: ToolRegistry, args: AgentHarnessModelToolCatalogArgs): readonly Record<string, unknown>[] {
+  const query = readString(args.query).toLowerCase();
+  const includeParameters = args.includeParameters === true;
+  const limit = readLimit(args.limit, 200);
+  return toolRegistry.getToolDefinitions()
+    .filter((tool) => !query || [tool.name, tool.description, ...(tool.sideEffects ?? [])].join('\n').toLowerCase().includes(query))
+    .sort((a, b) => a.name.localeCompare(b.name))
+    .slice(0, limit)
+    .map((tool) => ({
+      name: tool.name,
+      description: tool.description,
+      sideEffects: tool.sideEffects ?? [],
+      concurrency: tool.concurrency ?? 'parallel',
+      supportsProgress: tool.supportsProgress ?? false,
+      supportsStreamingOutput: tool.supportsStreamingOutput ?? false,
+      ...(includeParameters ? { parameters: tool.parameters } : {}),
+    }));
+}

package/src/tools/agent-harness-panel-metadata.ts

@@ -0,0 +1,121 @@
+import type { CommandContext } from '../input/command-registry.ts';
+import { agentWorkspaceCategoryForPanel, agentWorkspaceCommandForPanel } from '../input/agent-workspace-panel-route.ts';
+import type { PanelRegistration } from '../panels/types.ts';
+
+export interface AgentHarnessPanelArgs {
+  readonly query?: unknown;
+  readonly panelId?: unknown;
+  readonly category?: unknown;
+  readonly limit?: unknown;
+  readonly pane?: unknown;
+}
+
+function readString(value: unknown): string {
+  return typeof value === 'string' ? value.trim() : '';
+}
+
+function readLimit(value: unknown, fallback: number): number {
+  const parsed = typeof value === 'string' && value.trim() ? Number(value) : value;
+  if (typeof parsed !== 'number' || !Number.isFinite(parsed)) return fallback;
+  return Math.max(1, Math.min(500, Math.trunc(parsed)));
+}
+
+function panelManager(context: CommandContext) {
+  return context.workspace.panelManager ?? null;
+}
+
+function panelMatches(panel: Record<string, unknown>, query: string): boolean {
+  if (!query) return true;
+  return [
+    panel.id,
+    panel.name,
+    panel.category,
+    panel.description,
+    panel.workspaceRoute,
+  ].map((value) => String(value ?? '')).join('\n').toLowerCase().includes(query.toLowerCase());
+}
+
+function describePanelRegistration(context: CommandContext, registration: PanelRegistration): Record<string, unknown> {
+  const manager = panelManager(context);
+  const openPanel = manager?.getPanel(registration.id) ?? null;
+  const pane = manager?.getPaneOf(registration.id) ?? null;
+  const activePanel = manager?.getActivePanel() ?? null;
+  return {
+    id: registration.id,
+    name: registration.name,
+    icon: registration.icon,
+    category: registration.category,
+    description: registration.description,
+    preload: registration.preload === true,
+    open: openPanel !== null,
+    pane,
+    active: activePanel?.id === registration.id,
+    focused: activePanel?.id === registration.id,
+    workspaceRoute: {
+      categoryId: agentWorkspaceCategoryForPanel(registration.id),
+      command: agentWorkspaceCommandForPanel(registration.id),
+    },
+    policy: {
+      effect: 'ui-navigation',
+      confirmation: 'agent_harness mode:"open_panel" requires confirm:true and explicitUserRequest.',
+      boundary: 'Panels are Agent/TUI operator views. The model can inspect panel catalog/open state; panel routing uses the existing Agent workspace bridge and does not mutate connected-host lifecycle.',
+    },
+  };
+}
+
+export function totalHarnessPanels(context: CommandContext): number {
+  return panelManager(context)?.getRegisteredTypes().length ?? 0;
+}
+
+export function listHarnessPanels(context: CommandContext, args: AgentHarnessPanelArgs): readonly Record<string, unknown>[] {
+  const manager = panelManager(context);
+  if (!manager) return [];
+  const query = readString(args.query);
+  const category = readString(args.category);
+  const limit = readLimit(args.limit, 200);
+  return manager.getRegisteredTypes()
+    .map((registration) => describePanelRegistration(context, registration))
+    .filter((panel) => !category || panel.category === category)
+    .filter((panel) => panelMatches(panel, query))
+    .sort((a, b) => String(a.id).localeCompare(String(b.id)))
+    .slice(0, limit);
+}
+
+export function describeHarnessPanel(context: CommandContext, args: AgentHarnessPanelArgs): Record<string, unknown> | null {
+  const manager = panelManager(context);
+  if (!manager) return null;
+  const panelId = readString(args.panelId || args.query);
+  if (!panelId) return null;
+  const registration = manager.getRegisteredTypes().find((panel) => (
+    panel.id === panelId
+    || panel.name.toLowerCase() === panelId.toLowerCase()
+  ));
+  return registration ? describePanelRegistration(context, registration) : null;
+}
+
+export function openHarnessPanel(context: CommandContext, args: AgentHarnessPanelArgs): Record<string, unknown> {
+  const panel = describeHarnessPanel(context, args);
+  if (!panel) {
+    return {
+      status: 'unknown_panel',
+      panelId: readString(args.panelId || args.query) || '<missing>',
+      availablePanels: listHarnessPanels(context, { limit: 50 }).map((entry) => entry.id),
+    };
+  }
+  const requestedPane = readString(args.pane);
+  const pane = requestedPane === 'bottom' || requestedPane === 'top' ? requestedPane : undefined;
+  if (!context.showPanel) {
+    return {
+      status: 'route_unavailable',
+      panel,
+      note: 'The current runtime did not provide showPanel. Use the returned workspaceRoute from the TUI.',
+    };
+  }
+  context.showPanel(String(panel.id), pane);
+  return {
+    status: 'routed',
+    panel,
+    pane: pane ?? 'default',
+    note: 'Panel routing was handed to the current Agent shell bridge.',
+  };
+}

package/src/tools/agent-harness-tool.ts

@@ -17,11 +17,13 @@ import type {
   AgentWorkspaceRuntimeSnapshot,
 } from '../input/agent-workspace-types.ts';
 import { parseSlashCommand } from '../input/slash-command-parser.ts';
+import { blockedHarnessCliCommandTokens, describeHarnessCliCommand, listHarnessCliCommands, totalHarnessCliCommands } from './agent-harness-cli-metadata.ts';
+import { describeHarnessKeybinding, listHarnessKeybindings, listHarnessShortcuts, resetHarnessKeybinding, setHarnessKeybinding, totalHarnessKeybindings, totalHarnessShortcuts } from './agent-harness-keybinding-metadata.ts';
+import { describeHarnessPanel, listHarnessPanels, openHarnessPanel, totalHarnessPanels } from './agent-harness-panel-metadata.ts';
 import { describeLocalWorkspaceModelExecution, runLocalWorkspaceAction } from './agent-harness-local-operations.ts';
+import { listHarnessModelTools } from './agent-harness-model-tool-catalog.ts';
 import {
-  blockedConnectedHostCapabilities,
-  connectedHostCapabilityMap,
-  connectedHostRouteFamilies,
+  connectedHostSummary,
   describeCommandPolicy,
   settingsPolicySummary,
 } from './agent-harness-metadata.ts';
@@ -32,35 +34,31 @@ import {
   resetHarnessSetting,
   setHarnessSetting,
 } from '../agent/harness-control.ts';
-import { resolveAgentConnectedHostConnection } from '../agent/routine-schedule-promotion.ts';
-
-type AgentHarnessMode =
-  | 'summary'
-  | 'commands'
-  | 'command'
-  | 'run_command'
-  | 'settings'
-  | 'get_setting'
-  | 'set_setting'
-  | 'reset_setting'
-  | 'workspace'
-  | 'workspace_categories'
-  | 'workspace_actions'
-  | 'workspace_action'
-  | 'run_workspace_action'
-  | 'tools'
-  | 'connected_host';
+
+const MODES = [
+  'summary', 'cli_commands', 'cli_command', 'panels', 'panel', 'open_panel',
+  'shortcuts', 'keybindings', 'keybinding', 'set_keybinding', 'reset_keybinding',
+  'commands', 'command', 'run_command', 'settings', 'get_setting', 'set_setting',
+  'reset_setting', 'workspace', 'workspace_categories', 'workspace_actions',
+  'workspace_action', 'run_workspace_action', 'tools', 'connected_host',
+] as const;
+
+type AgentHarnessMode = typeof MODES[number];
 
 interface AgentHarnessToolArgs {
   readonly mode?: unknown;
   readonly query?: unknown;
   readonly command?: unknown;
+  readonly cliCommand?: unknown;
   readonly commandName?: unknown;
   readonly args?: unknown;
   readonly categoryId?: unknown;
+  readonly panelId?: unknown;
   readonly actionId?: unknown;
   readonly recordId?: unknown;
   readonly fields?: unknown;
+  readonly combo?: unknown;
+  readonly combos?: unknown;
   readonly key?: unknown;
   readonly value?: unknown;
   readonly category?: unknown;
@@ -68,6 +66,7 @@ interface AgentHarnessToolArgs {
   readonly includeHidden?: unknown;
   readonly includeParameters?: unknown;
   readonly limit?: unknown;
+  readonly pane?: unknown;
   readonly confirm?: unknown;
   readonly explicitUserRequest?: unknown;
 }
@@ -83,24 +82,6 @@ interface WorkspaceEditorContext {
   readonly selectedRoutine: AgentWorkspaceLocalLibraryItem | null;
 }
 
-const MODES: readonly AgentHarnessMode[] = [
-  'summary',
-  'commands',
-  'command',
-  'run_command',
-  'settings',
-  'get_setting',
-  'set_setting',
-  'reset_setting',
-  'workspace',
-  'workspace_categories',
-  'workspace_actions',
-  'workspace_action',
-  'run_workspace_action',
-  'tools',
-  'connected_host',
-];
-
 function isMode(value: unknown): value is AgentHarnessMode {
   return typeof value === 'string' && MODES.includes(value as AgentHarnessMode);
 }
@@ -132,9 +113,14 @@ function output(value: unknown): { readonly success: true; readonly output: stri
   };
 }
 
-function error(message: string): { readonly success: false; readonly error: string } {
-  return { success: false, error: message };
-}
+function error(message: string): { readonly success: false; readonly error: string } { return { success: false, error: message }; }
+
+const KEY_COMBO_PARAMETER_SCHEMA = {
+  type: 'object',
+  properties: { key: { type: 'string' }, ctrl: { type: 'boolean' }, shift: { type: 'boolean' }, alt: { type: 'boolean' } },
+  required: ['key'],
+  additionalProperties: false,
+} as const;
 
 function commandMatches(command: SlashCommand, query: string): boolean {
   if (!query) return true;
@@ -307,28 +293,6 @@ function listCommands(commandRegistry: CommandRegistry, args: AgentHarnessToolAr
     .map(describeCommand);
 }
 
-function listTools(toolRegistry: ToolRegistry, args: AgentHarnessToolArgs): readonly Record<string, unknown>[] {
-  const query = readString(args.query).toLowerCase();
-  const includeParameters = args.includeParameters === true;
-  const limit = readLimit(args.limit, 200);
-  return toolRegistry.getToolDefinitions()
-    .filter((tool) => {
-      if (!query) return true;
-      return [tool.name, tool.description, ...(tool.sideEffects ?? [])].join('\n').toLowerCase().includes(query);
-    })
-    .sort((a, b) => a.name.localeCompare(b.name))
-    .slice(0, limit)
-    .map((tool) => ({
-      name: tool.name,
-      description: tool.description,
-      sideEffects: tool.sideEffects ?? [],
-      concurrency: tool.concurrency ?? 'parallel',
-      supportsProgress: tool.supportsProgress ?? false,
-      supportsStreamingOutput: tool.supportsStreamingOutput ?? false,
-      ...(includeParameters ? { parameters: tool.parameters } : {}),
-    }));
-}
-
 function requireConfirmedAction(args: AgentHarnessToolArgs, action: string): string | null {
   const explicitUserRequest = readString(args.explicitUserRequest);
   if (!explicitUserRequest) return `${action} requires explicitUserRequest with the user's exact request or a short faithful summary.`;
@@ -544,30 +508,14 @@ async function runWorkspaceAction(
   });
 }
 
-function connectedHostSummary(context: CommandContext, toolRegistry: ToolRegistry): Record<string, unknown> {
-  const shellPaths = context.workspace.shellPaths;
-  const homeDirectory = shellPaths?.homeDirectory ?? context.platform.configManager.getHomeDirectory() ?? '';
-  const connection = resolveAgentConnectedHostConnection(context.platform.configManager, homeDirectory);
-  return {
-    baseUrl: connection.baseUrl,
-    operatorToken: connection.token ? 'configured' : 'missing',
-    tokenPath: connection.tokenPath,
-    ownership: 'external-connected-host',
-    lifecycle: 'GoodVibes Agent can use public connected-host operator routes, but does not start, stop, restart, install, expose, or mutate the host listener.',
-    routeFamilies: connectedHostRouteFamilies(),
-    capabilities: connectedHostCapabilityMap(toolRegistry),
-    blockedCapabilities: blockedConnectedHostCapabilities(),
-  };
-}
-
 export function createAgentHarnessTool(deps: AgentHarnessToolDeps): Tool {
   return {
     definition: {
       name: 'agent_harness',
       description: [
         'Discover and operate the GoodVibes Agent harness from the main conversation.',
-        'Use this tool to inspect Agent workspace actions, slash commands with policy metadata, model tools, connected-host capabilities, and Agent settings, or to invoke a workspace action/command through the same in-process command registry the user uses in the TUI.',
-        'Discovery modes are read-only. Setting writes, resets, slash command invocation, and workspace action invocation require confirm:true plus explicitUserRequest.',
+        'Use this tool to inspect Agent workspace actions, built-in panels, top-level CLI mirrors, keybindings, slash commands with policy metadata, model tools, connected-host capabilities, and Agent settings, or to invoke a workspace action/command through the same in-process command registry the user uses in the TUI.',
+        'Discovery modes are read-only. Setting/keybinding writes, resets, slash command invocation, and workspace action invocation require confirm:true plus explicitUserRequest.',
         'This tool preserves Agent product boundaries: connected-host lifecycle and listener posture stay externally owned, connected-host mode reports allowed and blocked route families, and secret-backed settings store raw values through the secret manager while config receives only a secret reference.',
       ].join(' '),
       parameters: {
@@ -584,11 +532,15 @@ export function createAgentHarnessTool(deps: AgentHarnessToolDeps): Tool {
           },
           command: {
             type: 'string',
-            description: 'Full slash command string for mode run_command, for example "/settings get provider.model".',
+            description: 'Full slash command string for mode run_command, for example "/settings get provider.model". In cli_command mode this may also hold a top-level CLI string such as "goodvibes-agent status --json".',
+          },
+          cliCommand: {
+            type: 'string',
+            description: 'Top-level CLI command string for mode cli_command, for example "goodvibes-agent status --json" or "profiles list". This mode is read-only metadata/parse inspection.',
           },
           commandName: {
             type: 'string',
-            description: 'Slash command root without the leading slash for mode command or run_command.',
+            description: 'Slash command root without the leading slash for mode command or run_command, or a top-level CLI command token for cli_command.',
           },
           args: {
             type: 'array',
@@ -599,15 +551,28 @@ export function createAgentHarnessTool(deps: AgentHarnessToolDeps): Tool {
             type: 'string',
             description: 'Agent workspace category id for workspace action filtering.',
           },
+          panelId: {
+            type: 'string',
+            description: 'Built-in panel id for panel or open_panel modes.',
+          },
           actionId: {
             type: 'string',
-            description: 'Agent workspace action id for workspace_action or run_workspace_action.',
+            description: 'Agent workspace action id for workspace_action or run_workspace_action, or keybinding action id for keybinding/set_keybinding/reset_keybinding.',
           },
           fields: {
             type: 'object',
             additionalProperties: { type: 'string' },
             description: 'Field values for run_workspace_action when the workspace action opens an editor form.',
           },
+          combo: {
+            ...KEY_COMBO_PARAMETER_SCHEMA,
+            description: 'Single key combo for set_keybinding, for example { "key": "g", "ctrl": true }.',
+          },
+          combos: {
+            type: 'array',
+            items: KEY_COMBO_PARAMETER_SCHEMA,
+            description: 'Multiple key combos for set_keybinding.',
+          },
           recordId: {
             type: 'string',
             description: 'Selected Agent-local record id for selection-based local workspace operations.',
@@ -644,9 +609,14 @@ export function createAgentHarnessTool(deps: AgentHarnessToolDeps): Tool {
             type: 'number',
             description: 'Maximum catalog entries to return.',
           },
+          pane: {
+            type: 'string',
+            enum: ['top', 'bottom'],
+            description: 'Preferred panel pane for open_panel when the current shell supports panel routing.',
+          },
           confirm: {
             type: 'boolean',
-            description: 'Required true for set_setting, reset_setting, run_command, and mutating run_workspace_action calls after an explicit user request.',
+            description: 'Required true for set_setting, reset_setting, run_command, open_panel, and mutating run_workspace_action calls after an explicit user request.',
           },
           explicitUserRequest: {
             type: 'string',
@@ -665,12 +635,20 @@ export function createAgentHarnessTool(deps: AgentHarnessToolDeps): Tool {
       try {
         if (args.mode === 'summary') {
           return output({
+            cliCommands: totalHarnessCliCommands(),
+            blockedCliCommandTokens: blockedHarnessCliCommandTokens(),
+            panels: totalHarnessPanels(deps.commandContext),
+            shortcuts: totalHarnessShortcuts(deps.commandContext),
+            keybindings: totalHarnessKeybindings(deps.commandContext),
             commands: deps.commandRegistry.list().length,
             settings: deps.commandContext.platform.configManager.getSchema().length,
             workspaceCategories: AGENT_WORKSPACE_CATEGORIES.length,
             workspaceActions: allWorkspaceActions().length,
             tools: deps.toolRegistry.getToolDefinitions().length,
             modelAccess: {
+              cliCommands: 'Use mode:"cli_commands" and mode:"cli_command" to inspect package CLI mirrors and their preferred in-process model routes. CLI modes are discovery-only.',
+              panels: 'Use mode:"panels" and mode:"panel" to inspect built-in panel catalog/open state; use mode:"open_panel" with confirm:true plus explicitUserRequest to route a visible panel/workspace change.',
+              shortcuts: 'Use mode:"shortcuts" to inspect fixed shortcuts plus configurable keybindings. Use mode:"set_keybinding" and mode:"reset_keybinding" with confirm:true plus explicitUserRequest to edit the same config file the user edits.',
               slashCommands: 'Use mode:"commands" and mode:"command" to inspect; use mode:"run_command" with confirm:true plus explicitUserRequest to execute.',
               workspace: 'Use mode:"workspace_actions" to list and mode:"workspace_action" for editor schemas; set includeParameters:true on workspace_actions to inline editor schemas.',
               settings: 'Use mode:"settings", mode:"get_setting", mode:"set_setting", and mode:"reset_setting".',
@@ -681,6 +659,53 @@ export function createAgentHarnessTool(deps: AgentHarnessToolDeps): Tool {
             connectedHost: connectedHostSummary(deps.commandContext, deps.toolRegistry),
           });
         }
+        if (args.mode === 'cli_commands') {
+          const commands = listHarnessCliCommands(args);
+          return output({
+            commands,
+            returned: commands.length,
+            total: totalHarnessCliCommands(),
+            blockedTokens: blockedHarnessCliCommandTokens(),
+            policy: 'CLI modes are read-only discovery. Use first-class model tools, workspace actions, settings modes, or confirmed slash-command mirrors for in-process operation.',
+          });
+        }
+        if (args.mode === 'cli_command') {
+          return output(describeHarnessCliCommand(args));
+        }
+        if (args.mode === 'panels') {
+          const panels = listHarnessPanels(deps.commandContext, args);
+          return output({
+            panels,
+            returned: panels.length,
+            total: totalHarnessPanels(deps.commandContext),
+            policy: 'Panel modes expose Agent/TUI operator view catalog and open state. open_panel is confirmation-gated and routes through the current Agent shell bridge.',
+          });
+        }
+        if (args.mode === 'panel') {
+          const panel = describeHarnessPanel(deps.commandContext, args);
+          return panel ? output(panel) : error(`Unknown panel ${readString(args.panelId || args.query) || '<missing>'}.`);
+        }
+        if (args.mode === 'open_panel') {
+          const confirmationError = requireConfirmedAction(args, 'Panel routing');
+          if (confirmationError) return error(confirmationError);
+          return output(openHarnessPanel(deps.commandContext, args));
+        }
+        if (args.mode === 'shortcuts') return output(listHarnessShortcuts(deps.commandContext, args));
+        if (args.mode === 'keybindings') return output(listHarnessKeybindings(deps.commandContext, args));
+        if (args.mode === 'keybinding') {
+          const binding = describeHarnessKeybinding(deps.commandContext, args);
+          return binding ? output(binding) : error(`Unknown keybinding action ${readString(args.actionId || args.key || args.query) || '<missing>'}.`);
+        }
+        if (args.mode === 'set_keybinding') {
+          const confirmationError = requireConfirmedAction(args, 'Keybinding mutation');
+          if (confirmationError) return error(confirmationError);
+          return output(setHarnessKeybinding(deps.commandContext, args));
+        }
+        if (args.mode === 'reset_keybinding') {
+          const confirmationError = requireConfirmedAction(args, 'Keybinding reset');
+          if (confirmationError) return error(confirmationError);
+          return output(resetHarnessKeybinding(deps.commandContext, args));
+        }
         if (args.mode === 'commands') {
           const commands = listCommands(deps.commandRegistry, args);
           return output({ commands, returned: commands.length, total: deps.commandRegistry.list().length });
@@ -749,7 +774,7 @@ export function createAgentHarnessTool(deps: AgentHarnessToolDeps): Tool {
         }
         if (args.mode === 'run_workspace_action') return runWorkspaceAction(deps, args);
         if (args.mode === 'tools') {
-          const tools = listTools(deps.toolRegistry, args);
+          const tools = listHarnessModelTools(deps.toolRegistry, args);
           return output({ tools, returned: tools.length, total: deps.toolRegistry.getToolDefinitions().length });
         }
         if (args.mode === 'connected_host') return output(connectedHostSummary(deps.commandContext, deps.toolRegistry));

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