@pellux/goodvibes-agent 0.1.116 → 1.0.0

package/src/runtime/ui-services.ts

@@ -58,19 +58,19 @@ export interface UiPlatformServices {
   readonly policyRuntimeState: RuntimeServices['policyRuntimeState'];
   readonly externalServices?: {
     inspect(): {
-      readonly daemonRunning: boolean;
-      readonly daemonPortInUse?: boolean;
+      readonly connectedHostRunning: boolean;
+      readonly connectedHostPortInUse?: boolean;
       readonly httpListenerRunning: boolean;
       readonly httpListenerPortInUse?: boolean;
-      readonly daemonStatus?: HostServiceStatus;
+      readonly connectedHostStatus?: HostServiceStatus;
       readonly httpListenerStatus?: HostServiceStatus;
     };
     restart(): Promise<{
-      readonly daemonRunning: boolean;
-      readonly daemonPortInUse?: boolean;
+      readonly connectedHostRunning: boolean;
+      readonly connectedHostPortInUse?: boolean;
       readonly httpListenerRunning: boolean;
       readonly httpListenerPortInUse?: boolean;
-      readonly daemonStatus?: HostServiceStatus;
+      readonly connectedHostStatus?: HostServiceStatus;
       readonly httpListenerStatus?: HostServiceStatus;
     }>;
   };

package/src/shell/blocking-input.ts

@@ -2,6 +2,7 @@ import type { ConversationManager } from '../core/conversation';
 import type { PermissionRequest } from '@pellux/goodvibes-sdk/platform/permissions';
 import type { SessionSnapshot } from '@/runtime/index.ts';
 import type { SystemMessageRouter } from '../core/system-message-router.ts';
+import { readConversationMessageSnapshots } from '../core/conversation-message-snapshot.ts';
 
 export type PendingPermissionState = PermissionRequest & {
   resolve: (approved: boolean, remember?: boolean) => void;
@@ -71,7 +72,7 @@ export function handleBlockingShellInput(
     if (data === '\x12') {
       const recovery = loadRecoveryConversation();
       if (recovery) {
-        conversation.fromJSON({ messages: recovery.messages as Parameters<typeof conversation.fromJSON>[0]['messages'] });
+        conversation.fromJSON({ messages: readConversationMessageSnapshots(recovery.messages) });
         systemMessageRouter.high('[Recovery] Session restored.');
       } else {
         systemMessageRouter.high('[Recovery] Failed to restore saved data.');

package/src/shell/service-settings-sync.ts

@@ -1,7 +1,7 @@
 import type { ConfigKey } from '@pellux/goodvibes-sdk/platform/config';
 import type { CliServiceRuntime } from '../cli/service-posture.ts';
 
-export const AGENT_EXTERNAL_DAEMON_SERVICE_MESSAGE = 'GoodVibes Agent uses connected GoodVibes services and does not install, start, stop, restart, or uninstall them. Manage service lifecycle outside Agent.';
+export const AGENT_EXTERNAL_HOST_SERVICE_MESSAGE = 'GoodVibes Agent uses a connected GoodVibes host and does not install, start, stop, restart, or uninstall it. Manage host lifecycle outside Agent.';
 
 export interface ServiceSettingsSyncChange {
   readonly key: ConfigKey;
@@ -11,13 +11,13 @@ export interface ServiceSettingsSyncChange {
 
 export interface ServiceSettingsSyncResult {
   readonly handled: boolean;
-  readonly action?: 'external-daemon-blocked' | 'unchanged';
+  readonly action?: 'connected-host-blocked' | 'unchanged';
   readonly message?: string;
   readonly error?: string;
 }
 
 export interface ServiceSettingsSyncOptions {
-  readonly allowExternalDaemonMutation?: false;
+  readonly allowExternalHostMutation?: false;
 }
 
 export function syncServiceSettingToPlatform(
@@ -30,15 +30,15 @@ export function syncServiceSettingToPlatform(
     return {
       handled: true,
       action: 'unchanged',
-      message: 'External daemon service setting unchanged',
+      message: 'Connected-host setting unchanged',
     };
   }
 
   runtime.configManager.setDynamic(change.key, change.previousValue);
   return {
     handled: true,
-    action: 'external-daemon-blocked',
-    message: AGENT_EXTERNAL_DAEMON_SERVICE_MESSAGE,
-    error: 'daemon_lifecycle_external',
+    action: 'connected-host-blocked',
+    message: AGENT_EXTERNAL_HOST_SERVICE_MESSAGE,
+    error: 'connected_host_lifecycle_external',
   };
 }

package/src/shell/ui-openers.ts

@@ -13,6 +13,7 @@ import type { SecretsManager } from '@pellux/goodvibes-sdk/platform/config';
 import type { ServiceInspectionQuery } from '../runtime/ui-service-queries.ts';
 import type { ModelPickerTargetInfo } from '../input/model-picker.ts';
 import { syncServiceSettingToPlatform } from './service-settings-sync.ts';
+import { agentWorkspaceCategoryForPanel } from '../input/agent-workspace-panel-route.ts';
 
 type WireShellUiOpenersOptions = {
   commandContext: CommandContext;
@@ -284,8 +285,8 @@ export function wireShellUiOpeners(options: WireShellUiOpenersOptions): void {
     render();
   };
 
-  commandContext.openAgentWorkspace = () => {
-    input.openAgentWorkspace(commandContext);
+  commandContext.openAgentWorkspace = (categoryId?: string) => {
+    input.openAgentWorkspace(commandContext, categoryId);
     render();
   };
 
@@ -296,42 +297,18 @@ export function wireShellUiOpeners(options: WireShellUiOpenersOptions): void {
   };
 
   commandContext.openPanelPicker = () => {
-    if (!panelManager.isVisible()) {
-      if (panelManager.getAllOpen().length === 0) {
-        try {
-          panelManager.open('panel-list');
-        } catch {
-          // non-fatal
-        }
-      }
-      panelManager.show();
-      input.panelFocused = true;
-      conversation.setSplashSuppressed(true);
-      conversation.rebuildHistory();
-    } else if (!input.panelFocused) {
-      if (panelManager.getAllOpen().length === 0) {
-        try {
-          panelManager.open('panel-list');
-        } catch {
-          // non-fatal
-        }
-      }
-      panelManager.show();
-      input.panelFocused = true;
-      conversation.setSplashSuppressed(true);
-      conversation.rebuildHistory();
-    } else {
-      panelManager.hide();
-      input.panelFocused = false;
-      conversation.setSplashSuppressed(false);
-      conversation.rebuildHistory();
-    }
+    panelManager.hide();
+    input.panelFocused = false;
+    conversation.setSplashSuppressed(false);
+    conversation.log('Panel picker is handled through Agent Workspace. Use /agent for current operator controls.', { fg: '214' });
+    input.openAgentWorkspace(commandContext, 'home');
+    conversation.rebuildHistory();
     render();
   };
 
   commandContext.focusPanels = () => {
-    if (!panelManager.isVisible() || panelManager.getAllOpen().length === 0) return;
-    input.panelFocused = true;
+    input.panelFocused = false;
+    input.openAgentWorkspace(commandContext, 'home');
     render();
   };
 
@@ -342,10 +319,12 @@ export function wireShellUiOpeners(options: WireShellUiOpenersOptions): void {
   };
 
   commandContext.showPanel = (panelId, pane) => {
-    panelManager.open(panelId, pane);
-    panelManager.show();
-    input.panelFocused = true;
-    conversation.setSplashSuppressed(true);
+    void pane;
+    panelManager.hide();
+    input.panelFocused = false;
+    conversation.setSplashSuppressed(false);
+    conversation.log(`Panel route "${panelId}" is handled through Agent Workspace. Opening the matching operator area.`, { fg: '214' });
+    input.openAgentWorkspace(commandContext, agentWorkspaceCategoryForPanel(panelId));
     conversation.rebuildHistory();
     render();
   };

package/src/tools/agent-analysis-registry-policy.ts

@@ -23,7 +23,6 @@ const READ_ONLY_ANALYZE_TOOL_MODES = [
   'surface',
   'breaking',
   'permissions',
-  'env_audit',
   'test_find',
 ] as const;
 

package/src/tools/agent-channel-send-tool.ts

@@ -0,0 +1,133 @@
+import type { ChannelDeliveryRouter } from '@pellux/goodvibes-sdk/platform/channels';
+import type { Tool } from '@pellux/goodvibes-sdk/platform/types';
+import type { ToolRegistry } from '@pellux/goodvibes-sdk/platform/tools';
+import {
+  buildAgentChannelDeliveryPreview,
+  deliverAgentChannelMessage,
+  formatAgentChannelDeliveryPreview,
+  formatAgentChannelDeliveryResult,
+} from '../agent/channel-delivery.ts';
+
+export interface AgentChannelSendToolArgs {
+  readonly message?: unknown;
+  readonly title?: unknown;
+  readonly channel?: unknown;
+  readonly route?: unknown;
+  readonly webhook?: unknown;
+  readonly link?: unknown;
+  readonly confirm?: unknown;
+  readonly explicitUserRequest?: unknown;
+}
+
+function readString(value: unknown): string | undefined {
+  return typeof value === 'string' && value.trim() ? value.trim() : undefined;
+}
+
+function readBoolean(value: unknown): boolean {
+  return value === true || value === 'true' || value === 'yes';
+}
+
+function failure(error: string): { readonly success: false; readonly error: string } {
+  return { success: false, error };
+}
+
+function output(text: string): { readonly success: true; readonly output: string } {
+  return { success: true, output: text };
+}
+
+export function createAgentChannelSendTool(
+  channelDeliveryRouter: Pick<ChannelDeliveryRouter, 'deliver' | 'listStrategies'>,
+): Tool {
+  return {
+    definition: {
+      name: 'agent_channel_send',
+      description: [
+        'Send one explicitly confirmed message through a configured GoodVibes Agent delivery target from the main conversation.',
+        'Use only when the user explicitly asks Agent to send, message, alert, or notify a channel target.',
+        'Exactly one target must be supplied: channel, route, webhook, or link.',
+        'This tool does not create channel routes, authorize accounts, manage connected-host hosting, use default knowledge, use non-Agent knowledge segments, create separate Agent jobs, run delegated review, or invoke arbitrary routes.',
+        'Set confirm:true only for an explicit user request. Otherwise return the preview/confirmation error.',
+      ].join(' '),
+      parameters: {
+        type: 'object',
+        properties: {
+          message: {
+            type: 'string',
+            description: 'Plain-text message to deliver.',
+          },
+          title: {
+            type: 'string',
+            description: 'Optional delivery title.',
+          },
+          channel: {
+            type: 'string',
+            description: 'Optional channel target surface[:route[:label]], such as slack:ops:Ops or telephony:+15551234567. Use exactly one target field.',
+          },
+          route: {
+            type: 'string',
+            description: 'Optional route id or route:label. Use exactly one target field.',
+          },
+          webhook: {
+            type: 'string',
+            description: 'Optional http(s) webhook URL. Use exactly one target field.',
+          },
+          link: {
+            type: 'string',
+            description: 'Optional link delivery target. Use exactly one target field.',
+          },
+          confirm: {
+            type: 'boolean',
+            description: 'Required true only when the user explicitly asked for this exact channel delivery.',
+          },
+          explicitUserRequest: {
+            type: 'string',
+            description: 'Short quote or summary of the user request that authorized this delivery.',
+          },
+        },
+        required: ['message', 'confirm', 'explicitUserRequest'],
+        additionalProperties: false,
+      },
+      sideEffects: ['network'],
+    },
+    execute: async (rawArgs: Record<string, unknown>) => {
+      const args = rawArgs as AgentChannelSendToolArgs;
+      const explicitUserRequest = readString(args.explicitUserRequest);
+      if (!explicitUserRequest) {
+        return failure('explicitUserRequest is required so channel delivery stays tied to a direct user request.');
+      }
+      const input = {
+        message: readString(args.message) ?? '',
+        ...(readString(args.title) ? { title: readString(args.title) } : {}),
+        ...(readString(args.channel) ? { channel: readString(args.channel) } : {}),
+        ...(readString(args.route) ? { route: readString(args.route) } : {}),
+        ...(readString(args.webhook) ? { webhook: readString(args.webhook) } : {}),
+        ...(readString(args.link) ? { link: readString(args.link) } : {}),
+      };
+      let preview: ReturnType<typeof buildAgentChannelDeliveryPreview>;
+      try {
+        preview = buildAgentChannelDeliveryPreview(input);
+      } catch (error) {
+        return failure(error instanceof Error ? error.message : String(error));
+      }
+      if (!readBoolean(args.confirm)) {
+        return failure([
+          formatAgentChannelDeliveryPreview(preview, channelDeliveryRouter.listStrategies().length),
+          '',
+          'Model tool confirmation required. Call this tool with confirm:true only when the user explicitly asked GoodVibes Agent to send this channel message.',
+        ].join('\n'));
+      }
+      try {
+        return output(formatAgentChannelDeliveryResult(await deliverAgentChannelMessage(channelDeliveryRouter, input)));
+      } catch (error) {
+        return failure(error instanceof Error ? error.message : String(error));
+      }
+    },
+  };
+}
+
+export function registerAgentChannelSendTool(
+  registry: ToolRegistry,
+  channelDeliveryRouter: Pick<ChannelDeliveryRouter, 'deliver' | 'listStrategies'>,
+): void {
+  registry.register(createAgentChannelSendTool(channelDeliveryRouter));
+}

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

@@ -10,7 +10,7 @@ export function wrapBlockedContextToolForAgentPolicy(tool: Tool): void {
   tool.definition.description = [
     'Blocked in GoodVibes Agent main conversation: non-Agent runtime context.',
     'Use explicit Agent CLI/slash status, compat, setup, and Agent Knowledge commands for product-scoped context.',
-    'Default Knowledge/Wiki, non-Agent knowledge segments, and non-Agent runtime assumptions are not Agent fallbacks.',
+    'Default knowledge, non-Agent knowledge segments, and non-Agent runtime assumptions are not Agent fallbacks.',
   ].join(' ');
   tool.definition.sideEffects = [];
   tool.definition.parameters = {