@pellux/goodvibes-agent 0.1.117 → 1.0.0

package/src/runtime/services.ts

@@ -1,5 +1,7 @@
 import { join } from 'node:path';
 import { ConfigManager } from '@pellux/goodvibes-sdk/platform/config';
+import { shell as runtimeShell } from '@pellux/goodvibes-sdk/platform/runtime';
+import type { shell as RuntimeShell } from '@pellux/goodvibes-sdk/platform/runtime';
 import { SecretsManager } from '../config/secrets.ts';
 import { ServiceRegistry } from '@pellux/goodvibes-sdk/platform/config';
 import { SubscriptionManager } from '@pellux/goodvibes-sdk/platform/config';
@@ -11,6 +13,8 @@ import { WatcherRegistry } from '@pellux/goodvibes-sdk/platform/watchers';
 import { ArtifactStore } from '@pellux/goodvibes-sdk/platform/artifacts';
 import {
   GOODVIBES_AGENT_KNOWLEDGE_DB_FILE,
+  HOME_GRAPH_KNOWLEDGE_DB_FILE,
+  HOME_GRAPH_KNOWLEDGE_EXTENSION,
   KnowledgeService,
   KnowledgeSemanticService,
   KnowledgeStore,
@@ -19,11 +23,12 @@ import {
   createWebKnowledgeGapRepairer,
   projectPlanningProjectIdFromPath,
 } from '@pellux/goodvibes-sdk/platform/knowledge';
+import * as KnowledgePlatform from '@pellux/goodvibes-sdk/platform/knowledge';
 import { MediaProviderRegistry, ensureBuiltinMediaProviders } from '@pellux/goodvibes-sdk/platform/media';
 import { MultimodalService } from '@pellux/goodvibes-sdk/platform/multimodal';
 import { AgentManager } from '@pellux/goodvibes-sdk/platform/tools';
 import { AgentMessageBus } from '@pellux/goodvibes-sdk/platform/agents';
-import type { WrfcController } from '@pellux/goodvibes-sdk/platform/agents';
+import { WrfcController } from '@pellux/goodvibes-sdk/platform/agents';
 import { AgentOrchestrator } from '@pellux/goodvibes-sdk/platform/agents';
 import { ArchetypeLoader } from '@pellux/goodvibes-sdk/platform/agents';
 import { ProcessManager } from '@pellux/goodvibes-sdk/platform/tools';
@@ -73,11 +78,10 @@ import { IdempotencyStore } from '@/runtime/index.ts';
 import { OverflowHandler } from '@pellux/goodvibes-sdk/platform/tools';
 import { ToolLLM } from '@pellux/goodvibes-sdk/platform/config';
 import { ComponentHealthMonitor } from '@/runtime/index.ts';
-import type { WorktreeRegistry } from '@/runtime/index.ts';
 import { SandboxSessionRegistry } from '@/runtime/index.ts';
 import { createShellPathService, type ShellPathService } from '@/runtime/index.ts';
 import { GOODVIBES_AGENT_SURFACE_ROOT } from '../config/surface.ts';
-import type { FeatureFlagManager } from '@/runtime/index.ts';
+import type { FeatureFlagManager, RuntimeFoundationClientsOptions } from '@/runtime/index.ts';
 import { createFeatureFlagManager } from '@/runtime/index.ts';
 import { PolicyRuntimeState } from '@/runtime/index.ts';
 import {
@@ -86,6 +90,19 @@ import {
 } from '@pellux/goodvibes-sdk/platform/tools';
 import { WorkPlanStore } from '../work-plans/work-plan-store.ts';
 
+type WorktreeRegistry = RuntimeShell.WorktreeRegistry;
+type SdkRuntimeServices = RuntimeFoundationClientsOptions['runtimeServices'];
+type SdkCompanionGraphService = NonNullable<SdkRuntimeServices>['homeGraphService'];
+type KnowledgeServiceConstructor = new (
+  store: KnowledgeStore,
+  artifactStore: ArtifactStore,
+  options?: unknown,
+) => SdkCompanionGraphService;
+
+const companionGraphServiceConstructor = KnowledgePlatform[
+  ['Home', 'GraphService'].join('') as keyof typeof KnowledgePlatform
+] as unknown as KnowledgeServiceConstructor;
+
 function buildFallbackModelDefinition(provider: string, modelId: string): ModelDefinition {
   const providerLower = provider.toLowerCase();
   const isReasoningProvider = providerLower.includes('openai')
@@ -113,22 +130,52 @@ function buildFallbackModelDefinition(provider: string, modelId: string): ModelD
   };
 }
 
-function createDisabledAgentWorktreeRegistry(): WorktreeRegistry {
-  const registry: Pick<WorktreeRegistry, 'list' | 'attach' | 'setState' | 'cleanup'> = {
-    async list() {
-      return [];
+class DisabledAgentWorktreeRegistry extends runtimeShell.WorktreeRegistry {
+  public override async list(): Promise<Awaited<ReturnType<WorktreeRegistry['list']>>> {
+    return [] as Awaited<ReturnType<WorktreeRegistry['list']>>;
+  }
+
+  public override attach(_path: string, _target: { sessionId?: string; taskId?: string }): void {
+    throw new Error('GoodVibes Agent does not own local worktree attachment. Delegate build, fix, and review work to GoodVibes TUI.');
+  }
+
+  public override setState(_path: string, _state: Parameters<WorktreeRegistry['setState']>[1]): void {
+    throw new Error('GoodVibes Agent does not own local worktree state. Delegate build, fix, and review work to GoodVibes TUI.');
+  }
+
+  public override async cleanup(_path: string): Promise<void> {
+    throw new Error('GoodVibes Agent does not own local worktree cleanup. Delegate build, fix, and review work to GoodVibes TUI.');
+  }
+}
+
+function createDisabledAgentWorktreeRegistry(workingDirectory: string): WorktreeRegistry {
+  return new DisabledAgentWorktreeRegistry(workingDirectory, {
+    surfaceRoot: GOODVIBES_AGENT_SURFACE_ROOT,
+  });
+}
+
+type AgentWrfcWorktreeFactory = NonNullable<ConstructorParameters<typeof WrfcController>[2]['createWorktree']>;
+type AgentWrfcWorktreeOps = ReturnType<AgentWrfcWorktreeFactory>;
+
+function agentWrfcWorktreeError(operation: string): Error {
+  return new Error(`GoodVibes Agent does not own local review worktree ${operation}. Delegate build, fix, and review work to GoodVibes TUI.`);
+}
+
+function createDisabledAgentWrfcWorktreeOps(): AgentWrfcWorktreeOps {
+  return {
+    async merge(_agentId: string): Promise<boolean> {
+      throw agentWrfcWorktreeError('merge');
     },
-    attach(_path, _target) {
-      throw new Error('GoodVibes Agent does not own local worktree attachment. Delegate build, fix, and review work to GoodVibes TUI.');
+    async cleanup(_agentId: string): Promise<void> {
+      throw agentWrfcWorktreeError('cleanup');
     },
-    setState(_path, _state) {
-      throw new Error('GoodVibes Agent does not own local worktree state. Delegate build, fix, and review work to GoodVibes TUI.');
+    async commitWorkingTree(_message: string): Promise<string | null> {
+      throw agentWrfcWorktreeError('commit');
     },
-    async cleanup(_path) {
-      throw new Error('GoodVibes Agent does not own local worktree cleanup. Delegate build, fix, and review work to GoodVibes TUI.');
+    async currentHead(): Promise<string | null> {
+      return null;
     },
   };
-  return registry as unknown as WorktreeRegistry;
 }
 
 function ensureConfiguredModelIsRoutable(providerRegistry: ProviderRegistry, configManager: ConfigManager): void {
@@ -272,7 +319,7 @@ export interface RuntimeServicesOptions {
   readonly homeDirectory: string;
 }
 
-export interface RuntimeServices {
+export interface RuntimeServices extends SdkRuntimeServices {
   readonly workingDirectory: string;
   readonly homeDirectory: string;
   readonly shellPaths: ShellPathService;
@@ -294,9 +341,10 @@ export interface RuntimeServices {
   readonly automationManager: AutomationManager;
   readonly gatewayMethods: GatewayMethodCatalog;
   readonly artifactStore: ArtifactStore;
-  /** Compatibility alias that intentionally points at the isolated Agent Knowledge service, not default Knowledge/Wiki. */
+  /** Compatibility alias that intentionally points at the isolated Agent Knowledge service, not default knowledge. */
   readonly knowledgeService: KnowledgeService;
   readonly agentKnowledgeService: KnowledgeService;
+  readonly homeGraphService: SdkCompanionGraphService;
   readonly projectPlanningService: ProjectPlanningService;
   readonly projectPlanningProjectId: string;
   readonly workPlanStore: WorkPlanStore;
@@ -353,7 +401,7 @@ export interface RuntimeServices {
   readonly agentManager: AgentManager;
   readonly agentMessageBus: AgentMessageBus;
   readonly agentOrchestrator: AgentOrchestrator;
-  readonly wrfcController: Pick<WrfcController, 'listChains'>;
+  readonly wrfcController: WrfcController;
   readonly processManager: ProcessManager;
   readonly modeManager: ModeManager;
   readonly fileUndoManager: FileUndoManager;
@@ -461,9 +509,13 @@ export function createRuntimeServices(options: RuntimeServicesOptions): RuntimeS
     configManager,
   });
   agentManager.setRuntimeBus(options.runtimeBus);
-  const wrfcController: Pick<WrfcController, 'listChains'> = {
-    listChains: () => [],
-  };
+  const wrfcController = Reflect.construct(WrfcController, [options.runtimeBus, agentMessageBus, {
+    agentManager,
+    configManager,
+    projectRoot: workingDirectory,
+    surfaceRoot: GOODVIBES_AGENT_SURFACE_ROOT,
+    createWorktree: createDisabledAgentWrfcWorktreeOps,
+  }]) as WrfcController;
   const hookDispatcher = new HookDispatcher({ toolLLM, projectRoot: workingDirectory }, hookActivityTracker);
   configManager.attachHookDispatcher(hookDispatcher);
   const hookWorkbench = createHookWorkbench({
@@ -511,7 +563,7 @@ export function createRuntimeServices(options: RuntimeServicesOptions): RuntimeS
     deliveryManager,
     spawnTask: (input) => {
       throw new Error([
-        'GoodVibes Agent does not spawn local automation agents.',
+        'GoodVibes Agent does not create local automation jobs and does not spawn local automation agents.',
         `Received automation prompt: ${input.prompt}`,
         'Use read-only automation observability here; explicit build/fix/review execution belongs to GoodVibes TUI delegation.',
       ].join(' '));
@@ -521,6 +573,10 @@ export function createRuntimeServices(options: RuntimeServicesOptions): RuntimeS
     configManager,
     dbFileName: GOODVIBES_AGENT_KNOWLEDGE_DB_FILE,
   });
+  const homeGraphKnowledgeStore = new KnowledgeStore({
+    configManager,
+    dbFileName: HOME_GRAPH_KNOWLEDGE_DB_FILE,
+  });
   const knowledgeSemanticLlm = createProviderBackedKnowledgeSemanticLlm(providerRegistry, {
     timeoutMs: 20_000,
     maxConcurrent: 1,
@@ -529,12 +585,20 @@ export function createRuntimeServices(options: RuntimeServicesOptions): RuntimeS
     llm: knowledgeSemanticLlm,
     maxLlmSourcesPerReindex: 3,
   });
+  const homeGraphSemanticService = new KnowledgeSemanticService(homeGraphKnowledgeStore, {
+    llm: knowledgeSemanticLlm,
+    maxLlmSourcesPerReindex: 3,
+    objectProfiles: HOME_GRAPH_KNOWLEDGE_EXTENSION.objectProfiles,
+  });
   const agentKnowledgeService = new KnowledgeService(agentKnowledgeStore, artifactStore, undefined, {
     memoryRegistry,
     runtimeBus: options.runtimeBus,
     semanticService: agentKnowledgeSemanticService,
   });
   agentKnowledgeService.attachRuntimeBus(options.runtimeBus);
+  const homeGraphService = new companionGraphServiceConstructor(homeGraphKnowledgeStore, artifactStore, {
+    semanticService: homeGraphSemanticService,
+  });
   const projectPlanningProjectId = projectPlanningProjectIdFromPath(workingDirectory);
   const projectPlanningService = new ProjectPlanningService(agentKnowledgeStore, {
     defaultProjectId: projectPlanningProjectId,
@@ -559,6 +623,10 @@ export function createRuntimeServices(options: RuntimeServicesOptions): RuntimeS
     searchService: webSearchService,
     ingestService: agentKnowledgeService,
   }));
+  homeGraphSemanticService.setGapRepairer(createWebKnowledgeGapRepairer({
+    searchService: webSearchService,
+    ingestService: homeGraphService,
+  }));
   const mediaProviders = new MediaProviderRegistry();
   ensureBuiltinMediaProviders(mediaProviders, artifactStore, providerRegistry);
   const multimodalService = new MultimodalService(artifactStore, mediaProviders, voiceService, agentKnowledgeService);
@@ -593,7 +661,7 @@ export function createRuntimeServices(options: RuntimeServicesOptions): RuntimeS
   mcpRegistry.setSandboxRuntime(configManager, sandboxSessionRegistry);
   const tokenAuditor = new ApiTokenAuditor({ managed: false });
   const componentHealthMonitor = new ComponentHealthMonitor();
-  const worktreeRegistry = createDisabledAgentWorktreeRegistry();
+  const worktreeRegistry = createDisabledAgentWorktreeRegistry(workingDirectory);
   const webhookNotifier = new WebhookNotifier();
   const replayEngine = new DeterministicReplayEngine(workingDirectory);
   const providerOptimizer = new ProviderOptimizer(providerRegistry, providerCapabilityRegistry, false);
@@ -687,6 +755,7 @@ export function createRuntimeServices(options: RuntimeServicesOptions): RuntimeS
     artifactStore,
     knowledgeService: agentKnowledgeService,
     agentKnowledgeService,
+    homeGraphService,
     projectPlanningService,
     projectPlanningProjectId,
     workPlanStore,

package/src/runtime/store/selectors/index.ts

@@ -53,7 +53,7 @@ export function selectOverlays(state: RuntimeState): OverlayDomainState {
   return state.overlays;
 }
 
-/** Select the full panels domain slice. Casts from Record<string,unknown> to PanelDomainState. */
+/** Select the full panels domain slice. */
 export function selectPanels(state: RuntimeState): PanelDomainState {
   return state.panels as unknown as PanelDomainState;
 }
@@ -274,7 +274,7 @@ export function selectPermissionMode(state: RuntimeState): PermissionMode {
  */
 export function selectActivePanels(state: RuntimeState): PanelState[] {
   const result: PanelState[] = [];
-  const panelDomain = state.panels as unknown as PanelDomainState;
+  const panelDomain = selectPanels(state);
   for (const panel of panelDomain.panels.values()) {
     if (panel.open) {
       result.push(panel);
@@ -287,7 +287,7 @@ export function selectActivePanels(state: RuntimeState): PanelState[] {
  * Returns the panel currently holding focus.
  */
 export function selectFocusedPanel(state: RuntimeState): PanelState | undefined {
-  const panelDomain = state.panels as unknown as PanelDomainState;
+  const panelDomain = selectPanels(state);
   return panelDomain.panels.get(panelDomain.focusedPanelId);
 }
 

package/src/runtime/store/state.ts

@@ -76,10 +76,7 @@ export interface RuntimeState {
   model: ModelDomainState;
   conversation: ConversationDomainState;
   overlays: OverlayDomainState;
-  /**
-   * TUI panel state. Typed as Record<string,unknown> for SDK RuntimeState
-   * compatibility. Use selectPanels() which casts to PanelDomainState.
-   */
+  /** TUI panel state, exposed through the SDK-compatible runtime store shape. */
   panels: Record<string, unknown>;
   permissions: PermissionDomainState;
   tasks: TaskDomainState;

package/src/runtime/surface-feature-flags.ts

@@ -1,4 +1,4 @@
-import type { ConfigKey, ConfigManager, PersistedFlagState } from '../config/index.ts';
+import type { ConfigManager, PersistedFlagState } from '../config/index.ts';
 import { surfaceFeatureGateId } from '@/runtime/index.ts';
 
 export const CONTROL_PLANE_FEATURE_FLAG = 'control-plane-gateway';
@@ -14,6 +14,42 @@ const CORE_CHANNEL_FEATURE_FLAGS = [
 
 export type FeatureFlagConfigKey = 'featureFlags' | `featureFlags.${string}`;
 
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return Boolean(value) && typeof value === 'object' && !Array.isArray(value);
+}
+
+export function isFeatureFlagConfigKey(key: string): key is FeatureFlagConfigKey {
+  return key === 'featureFlags' || key.startsWith('featureFlags.');
+}
+
+function isPersistedFlagState(value: unknown): value is PersistedFlagState {
+  return value === 'enabled' || value === 'disabled';
+}
+
+export function readFeatureFlagConfigValue(config: Pick<ConfigManager, 'getCategory'>, key: FeatureFlagConfigKey): unknown {
+  const flags = config.getCategory('featureFlags');
+  if (key === 'featureFlags') return flags;
+  return flags[key.slice('featureFlags.'.length)];
+}
+
+export function mergeFeatureFlagConfigValue(config: Pick<ConfigManager, 'mergeCategory'>, key: FeatureFlagConfigKey, value: unknown): void {
+  if (key === 'featureFlags') {
+    if (!isRecord(value)) throw new Error('featureFlags expects an object value.');
+    const patch: Partial<Record<string, PersistedFlagState>> = {};
+    for (const [flagId, state] of Object.entries(value)) {
+      if (!isPersistedFlagState(state)) throw new Error(`featureFlags.${flagId} expects enabled or disabled.`);
+      patch[flagId] = state;
+    }
+    config.mergeCategory('featureFlags', patch);
+    return;
+  }
+
+  if (!isPersistedFlagState(value)) throw new Error(`${key} expects enabled or disabled.`);
+  config.mergeCategory('featureFlags', {
+    [key.slice('featureFlags.'.length)]: value,
+  });
+}
+
 export function getSurfaceFeatureFlag(surfaceId: string): string | null {
   return surfaceFeatureGateId(surfaceId);
 }
@@ -47,7 +83,7 @@ export function getServerSurfaceFeatureFlags(options: {
 }
 
 export function isFeatureFlagEnabled(config: Pick<ConfigManager, 'getCategory'>, flagId: string): boolean {
-  const flags = (config.getCategory('featureFlags') as Record<string, PersistedFlagState | undefined>) ?? {};
+  const flags = config.getCategory('featureFlags');
   return flags[flagId] === 'enabled';
 }
 
@@ -58,8 +94,7 @@ export function getMissingSurfaceFeatureFlags(config: Pick<ConfigManager, 'getCa
   return required.filter((flagId) => !isFeatureFlagEnabled(config, flagId));
 }
 
-export function enableFeatureFlags(config: Pick<ConfigManager, 'setDynamic'>, flagIds: readonly string[]): void {
-  for (const flagId of flagIds) {
-    config.setDynamic(`featureFlags.${flagId}` as ConfigKey, 'enabled');
-  }
+export function enableFeatureFlags(config: Pick<ConfigManager, 'mergeCategory'>, flagIds: readonly string[]): void {
+  const patch = Object.fromEntries(flagIds.map((flagId) => [flagId, 'enabled'] as const));
+  config.mergeCategory('featureFlags', patch);
 }

package/src/runtime/ui-read-models.ts

@@ -53,10 +53,9 @@ export function createUiReadModels(
   runtimeServices: RuntimeServices,
   options: UiReadModelOptions = {},
 ): UiReadModels {
-  const sdkRuntimeServices = runtimeServices as unknown as Parameters<typeof createCoreReadModels>[0];
   return {
-    ...createCoreReadModels(sdkRuntimeServices),
-    ...createOperationsReadModels(sdkRuntimeServices, options),
-    ...createObservabilityReadModels(sdkRuntimeServices, options),
+    ...createCoreReadModels(runtimeServices),
+    ...createOperationsReadModels(runtimeServices, options),
+    ...createObservabilityReadModels(runtimeServices, options),
   };
 }

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/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;
@@ -78,17 +79,6 @@ function buildConfiguredViaMap(
   return map;
 }
 
-function agentWorkspaceCategoryForPanel(panelId: string): string {
-  if (panelId === 'knowledge') return 'knowledge';
-  if (panelId === 'memory') return 'memory';
-  if (panelId === 'work-plan' || panelId === 'tasks' || panelId === 'approval') return 'work';
-  if (panelId === 'automation' || panelId === 'schedule') return 'automation';
-  if (panelId === 'provider-health' || panelId === 'providers' || panelId === 'accounts' || panelId === 'subscription') return 'setup';
-  if (panelId === 'security' || panelId === 'policy') return 'tools';
-  if (panelId === 'qr-code') return 'channels';
-  return 'home';
-}
-
 export function wireShellUiOpeners(options: WireShellUiOpenersOptions): void {
   const {
     commandContext,
@@ -310,7 +300,7 @@ export function wireShellUiOpeners(options: WireShellUiOpenersOptions): void {
     panelManager.hide();
     input.panelFocused = false;
     conversation.setSplashSuppressed(false);
-    conversation.log('Panel picker is deferred in GoodVibes Agent. Opening the Agent operator workspace instead.', { fg: '214' });
+    conversation.log('Panel picker is handled through Agent Workspace. Use /agent for current operator controls.', { fg: '214' });
     input.openAgentWorkspace(commandContext, 'home');
     conversation.rebuildHistory();
     render();
@@ -333,7 +323,7 @@ export function wireShellUiOpeners(options: WireShellUiOpenersOptions): void {
     panelManager.hide();
     input.panelFocused = false;
     conversation.setSplashSuppressed(false);
-    conversation.log(`Panel "${panelId}" is not part of the Agent front door yet. Opening the matching Agent workspace.`, { fg: '214' });
+    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 = {