@pellux/goodvibes-agent 0.1.114 → 0.1.117

package/src/runtime/agent-runtime-events.ts

@@ -0,0 +1,129 @@
+import type { ConfigManager } from '@pellux/goodvibes-sdk/platform/config';
+import type { ConversationFollowUpItem } from '@pellux/goodvibes-sdk/platform/core';
+import type { AgentManager } from '@pellux/goodvibes-sdk/platform/tools';
+import type {
+  AgentEvent,
+  ProviderEvent,
+  RuntimeEventBus,
+} from '@/runtime/index.ts';
+import type { createDomainDispatch } from './store/index.ts';
+
+const AGENT_STATUS_INTERVAL_MS = 30_000;
+
+export interface AgentRuntimeMessageRouter {
+  low(message: string): void;
+  high(message: string): void;
+}
+
+export interface AgentRuntimeEventBridgeOptions {
+  readonly runtimeBus: RuntimeEventBus;
+  readonly domainDispatch: ReturnType<typeof createDomainDispatch>;
+  readonly getSystemMessageRouter: () => AgentRuntimeMessageRouter | null;
+  readonly queueConversationFollowUp?: (item: ConversationFollowUpItem) => void;
+  readonly requestRender: () => void;
+  readonly configManager: ConfigManager;
+  readonly agentManager: AgentManager;
+}
+
+function withRouter(
+  getSystemMessageRouter: () => AgentRuntimeMessageRouter | null,
+  action: (router: AgentRuntimeMessageRouter) => void,
+): void {
+  const router = getSystemMessageRouter();
+  if (router) action(router);
+}
+
+function formatAgentTask(task: string): string {
+  return task.length > 50 ? `${task.slice(0, 50)}...` : task;
+}
+
+export function registerAgentRuntimeEvents(options: AgentRuntimeEventBridgeOptions): {
+  unsubs: Array<() => void>;
+  agentStatusIntervalRef: { value: ReturnType<typeof setInterval> | null };
+} {
+  const {
+    runtimeBus,
+    domainDispatch,
+    getSystemMessageRouter,
+    queueConversationFollowUp,
+    requestRender,
+    agentManager,
+  } = options;
+  const unsubs: Array<() => void> = [];
+
+  unsubs.push(runtimeBus.onDomain('turn', (env) => {
+    domainDispatch.dispatchTurnEvent(env.payload);
+  }));
+  unsubs.push(runtimeBus.onDomain('agents', (env) => {
+    domainDispatch.dispatchAgentEvent(env.payload);
+  }));
+  unsubs.push(runtimeBus.onDomain('orchestration', (env) => {
+    domainDispatch.dispatchOrchestrationEvent(env.payload);
+  }));
+  unsubs.push(runtimeBus.onDomain('communication', (env) => {
+    domainDispatch.dispatchCommunicationEvent(env.payload);
+  }));
+  unsubs.push(runtimeBus.onDomain('compaction', (env) => {
+    domainDispatch.dispatchCompactionEvent(env.payload);
+  }));
+  unsubs.push(runtimeBus.onDomain('transport', (env) => {
+    domainDispatch.dispatchTransportEvent(env.payload);
+  }));
+
+  unsubs.push(runtimeBus.on<Extract<ProviderEvent, { type: 'MODEL_FALLBACK' }>>('MODEL_FALLBACK', ({ payload }) => {
+    withRouter(getSystemMessageRouter, (router) => {
+      router.high(`[Model] ${payload.from} exhausted across all providers. Automatically falling back to ${payload.to} via ${payload.provider}.`);
+    });
+    requestRender();
+  }));
+  unsubs.push(runtimeBus.on<Extract<AgentEvent, { type: 'AGENT_STREAM_DELTA' }>>('AGENT_STREAM_DELTA', () => {
+    requestRender();
+  }));
+  unsubs.push(runtimeBus.on<Extract<AgentEvent, { type: 'AGENT_PROGRESS' }>>('AGENT_PROGRESS', () => {
+    requestRender();
+  }));
+  unsubs.push(runtimeBus.on<Extract<AgentEvent, { type: 'AGENT_COMPLETED' }>>('AGENT_COMPLETED', ({ payload }) => {
+    const record = agentManager.getStatus(payload.agentId);
+    if (record) {
+      const durationSeconds = record.completedAt !== undefined ? Math.round((record.completedAt - record.startedAt) / 1000) : 0;
+      const taskSnippet = formatAgentTask(record.task);
+      withRouter(getSystemMessageRouter, (router) => {
+        router.low(`[Agent task] ${record.template} ${payload.agentId.slice(-8)} completed in ${durationSeconds}s: "${taskSnippet}"`);
+      });
+      queueConversationFollowUp?.({
+        key: `agent:${payload.agentId}:completed`,
+        summary: `${record.template} agent ${payload.agentId.slice(-8)} completed "${taskSnippet}" in ${durationSeconds}s after ${record.toolCallCount} tool calls.`,
+      });
+    }
+    requestRender();
+  }));
+  unsubs.push(runtimeBus.on<Extract<AgentEvent, { type: 'AGENT_FAILED' }>>('AGENT_FAILED', ({ payload }) => {
+    const record = agentManager.getStatus(payload.agentId);
+    if (record && record.status !== 'cancelled') {
+      const durationSeconds = record.completedAt !== undefined ? Math.round((record.completedAt - record.startedAt) / 1000) : 0;
+      const taskSnippet = formatAgentTask(record.task);
+      withRouter(getSystemMessageRouter, (router) => {
+        router.low(`[Agent task] ${record.template} ${payload.agentId.slice(-8)} failed in ${durationSeconds}s: ${payload.error.slice(0, 80)}`);
+      });
+      queueConversationFollowUp?.({
+        key: `agent:${payload.agentId}:failed`,
+        summary: `${record.template} agent ${payload.agentId.slice(-8)} failed while working on "${taskSnippet}": ${payload.error.slice(0, 120)}`,
+      });
+    }
+    requestRender();
+  }));
+
+  const agentStatusIntervalRef = { value: null as ReturnType<typeof setInterval> | null };
+  agentStatusIntervalRef.value = setInterval(() => {
+    const running = agentManager.list().filter((agent) => agent.status === 'running');
+    if (running.length === 0) return;
+    const lines = running.map((agent) => `  ${agent.id.slice(-8)}: ${agent.progress ?? agent.status}`);
+    withRouter(getSystemMessageRouter, (router) => {
+      router.low(`[Agent task] ${running.length} running:\n${lines.join('\n')}`);
+    });
+    requestRender();
+  }, AGENT_STATUS_INTERVAL_MS);
+  agentStatusIntervalRef.value.unref?.();
+
+  return { unsubs, agentStatusIntervalRef };
+}

package/src/runtime/bootstrap-command-parts.ts

@@ -171,8 +171,9 @@ export function createBootstrapCommandActions(
   } = options;
 
   const showPanel = (panelId: string, pane?: 'top' | 'bottom') => {
-    panelManager.open(panelId, pane);
-    panelManager.show();
+    void pane;
+    panelManager.hide();
+    conversation.log(`Panel "${panelId}" is deferred in GoodVibes Agent. Use /agent for the operator workspace.`, { fg: '214' });
     requestRender();
   };
 

package/src/runtime/bootstrap-core.ts

@@ -26,12 +26,12 @@ import {
 } from '@/runtime/index.ts';
 import { loadBootstrapSystemPrompt, syncConfiguredServices } from '@/runtime/index.ts';
 import { registerBootstrapHookBridge } from '@/runtime/index.ts';
-import { registerBootstrapRuntimeEvents } from '@/runtime/index.ts';
 import { createRuntimeServices, type RuntimeServices } from './services.ts';
 import { createUiRuntimeServices, type UiRuntimeServices } from './ui-services.ts';
 import { installAgentToolPolicyGuard } from '../tools/agent-tool-policy-guard.ts';
 import { registerAgentLocalRegistryTool } from '../tools/agent-local-registry-tool.ts';
 import { GOODVIBES_AGENT_SURFACE_ROOT } from '../config/surface.ts';
+import { registerAgentRuntimeEvents } from './agent-runtime-events.ts';
 
 export interface BootstrapCoreState {
   readonly userSessionId: string;
@@ -211,7 +211,6 @@ export async function initializeBootstrapCore(
     agentManager: services.agentManager,
     agentMessageBus: services.agentMessageBus,
     archetypeLoader: services.archetypeLoader,
-    wrfcController: services.wrfcController,
     webSearchService: services.webSearchService,
     channelRegistry: services.channelPlugins,
     remoteRunnerRegistry: services.remoteRunnerRegistry,
@@ -314,7 +313,7 @@ export async function initializeBootstrapCore(
   const runtimeSessionIdRef = { value: userSessionId };
   const systemMessageRouterRef: { value: SystemMessageRouter | null } = { value: null };
   const conversationFollowUpRef: { value: ((item: ConversationFollowUpItem) => void) | null } = { value: null };
-  const { unsubs: runtimeUnsubs, agentStatusIntervalRef } = registerBootstrapRuntimeEvents({
+  const { unsubs: runtimeUnsubs, agentStatusIntervalRef } = registerAgentRuntimeEvents({
     runtimeBus,
     domainDispatch,
     getSystemMessageRouter: () => systemMessageRouterRef.value,
@@ -322,69 +321,10 @@ export async function initializeBootstrapCore(
     requestRender,
     configManager,
     agentManager: services.agentManager,
-    wrfcController: services.wrfcController,
   });
 
-  // ── TUI-specific WRFC constraint-propagation event subscriptions (SDK 0.23.0) ──
-  // These supplement the SDK's registerBootstrapRuntimeEvents which handles the
-  // core WORKFLOW_REVIEW_COMPLETED / WORKFLOW_CHAIN_CREATED messages.
-  // The SDK does not surface constraint-specific system messages; the TUI layer
-  // adds them here so operators can observe constraint enumeration and violations
-  // in the SystemMessagesPanel and main conversation.
-  runtimeUnsubs.push(
-    runtimeBus.on<Extract<import('@/runtime/index.ts').WorkflowEvent, { type: 'WORKFLOW_CONSTRAINTS_ENUMERATED' }>>(
-      'WORKFLOW_CONSTRAINTS_ENUMERATED',
-      ({ payload }) => {
-        const router = systemMessageRouterRef.value;
-        if (!router) return;
-        const count = payload.constraints.length;
-        if (count > 0) {
-          router.wrfc(
-            `[WRFC] Engineer enumerated ${count} constraint${count !== 1 ? 's' : ''} for chain ${payload.chainId.slice(0, 12)}`,
-            'low',
-          );
-        }
-        requestRender();
-      },
-    ),
-  );
-  runtimeUnsubs.push(
-    runtimeBus.on<Extract<import('@/runtime/index.ts').WorkflowEvent, { type: 'WORKFLOW_FIX_ATTEMPTED' }>>(
-      'WORKFLOW_FIX_ATTEMPTED',
-      ({ payload }) => {
-        const router = systemMessageRouterRef.value;
-        if (!router) return;
-        const targetIds = payload.targetConstraintIds;
-        if (targetIds && targetIds.length > 0) {
-          router.wrfc(
-            `[WRFC] Fix #${payload.attempt} targeting ${targetIds.length} constraint${targetIds.length !== 1 ? 's' : ''} on chain ${payload.chainId.slice(0, 12)}`,
-            'low',
-          );
-          requestRender();
-        }
-      },
-    ),
-  );
-  runtimeUnsubs.push(
-    runtimeBus.on<Extract<import('@/runtime/index.ts').WorkflowEvent, { type: 'WORKFLOW_REVIEW_COMPLETED' }>>(
-      'WORKFLOW_REVIEW_COMPLETED',
-      ({ payload }) => {
-        const router = systemMessageRouterRef.value;
-        if (!router) return;
-        const unsatisfied = payload.unsatisfiedConstraintIds;
-        if (!payload.passed && unsatisfied && unsatisfied.length > 0) {
-          router.wrfc(
-            `[WRFC] ✗ Chain ${payload.chainId.slice(0, 12)}: ${unsatisfied.length} constraint violation${unsatisfied.length !== 1 ? 's' : ''} forced failure`,
-            'high',
-          );
-          requestRender();
-        }
-      },
-    ),
-  );
-
-  // Subscribe to companion main-chat messages received from the daemon's HTTP layer.
-  // The daemon emits COMPANION_MESSAGE_RECEIVED on the runtime bus when a companion
+  // Subscribe to companion main-chat messages received from the connected host's HTTP layer.
+  // The connected host emits COMPANION_MESSAGE_RECEIVED on the runtime bus when a companion
   // POST /api/sessions/:id/messages with kind='message' arrives.
   //
   // bootstrap.ts patches orchestratorHandleUserInputRef.value after the Orchestrator

package/src/runtime/bootstrap-shell.ts

@@ -62,6 +62,43 @@ export interface BootstrapShellOptions {
   readonly completeModelSelectionSideEffect?: () => void;
 }
 
+type PlanningAnswerSubmit = (answer: string) => void;
+
+export interface PlanningAnswerSubmitBridgeOptions {
+  readonly getSubmitInput: () => PlanningAnswerSubmit | undefined;
+  readonly addSystemMessage: (message: string) => void;
+  readonly requestRender: () => void;
+  readonly defer?: (callback: () => void) => void;
+}
+
+export function submitPlanningAnswerWithShellFallback(
+  answer: string,
+  options: PlanningAnswerSubmitBridgeOptions,
+): void {
+  const submit = options.getSubmitInput();
+  if (submit) {
+    submit(answer);
+    return;
+  }
+
+  const defer = options.defer ?? ((callback) => {
+    setTimeout(callback, 0);
+  });
+  defer(() => {
+    const deferredSubmit = options.getSubmitInput();
+    if (deferredSubmit) {
+      deferredSubmit(answer);
+      return;
+    }
+
+    options.addSystemMessage([
+      '[Planning] Could not submit the selected answer because the prompt bridge is not ready.',
+      `Paste this answer into the prompt to continue planning: ${answer}`,
+    ].join('\n'));
+    options.requestRender();
+  });
+}
+
 export function createBootstrapShell(options: BootstrapShellOptions): BootstrapShellState {
   const {
     configManager,
@@ -113,10 +150,11 @@ export function createBootstrapShell(options: BootstrapShellOptions): BootstrapS
     resumeSession,
     requestRender,
     submitPlanningAnswer: (answer) => {
-      if (!commandContextRef?.submitInput) {
-        throw new Error('Planning answer submission is not wired yet.');
-      }
-      commandContextRef.submitInput(answer);
+      submitPlanningAnswerWithShellFallback(answer, {
+        getSubmitInput: () => commandContextRef?.submitInput,
+        addSystemMessage: (message) => conversation.addSystemMessage(message),
+        requestRender,
+      });
     },
     dismissPlanning: () => {
       services.panelManager.close('project-planning');

package/src/runtime/bootstrap.ts

@@ -10,7 +10,6 @@
  *   - lifecycle.ts: save/shutdown helpers
  */
 import { Orchestrator, type OrchestratorUserInputOptions } from '../core/orchestrator.ts';
-import { AcpManager } from '@pellux/goodvibes-sdk/platform/acp';
 import { getTierPromptSupplement, getTierForContextWindow } from '@pellux/goodvibes-sdk/platform/providers';
 import { logger } from '@pellux/goodvibes-sdk/platform/utils';
 import type { PermissionRequestHandler } from '@pellux/goodvibes-sdk/platform/permissions';
@@ -23,7 +22,6 @@ import type { RuntimeContext, BootstrapOptions } from './context.ts';
 import { shutdownRuntime, fireSessionStart, saveSession } from '@/runtime/index.ts';
 import { createTaskManager } from '@/runtime/index.ts';
 import { OpsControlPlane } from '@/runtime/index.ts';
-import { AcpTaskAdapter } from '@/runtime/index.ts';
 import type { SystemMessageRouter } from '../core/system-message-router.ts';
 import { emitSessionReady, emitSessionStarted } from '@/runtime/index.ts';
 import {
@@ -47,8 +45,8 @@ import { buildReviewedMemoryPrompt } from '../agent/memory-prompt.ts';
 
 const GOODVIBES_AGENT_OPERATOR_POLICY = [
   '## GoodVibes Agent Operator Policy',
-  '- Default to serial, proactive assistant work in the main conversation. Answer, inspect, summarize, remember useful non-secret facts, configure local Agent state, use read-only connected-service/operator routes, and take safe non-destructive actions without spawning local agents or WRFC.',
-  '- GoodVibes Agent connects to GoodVibes services owned outside this package. Do not start, stop, restart, install, expose, or mutate connected-service network/listener posture from Agent.',
+  '- Default to serial, proactive assistant work in the main conversation. Answer, inspect, summarize, remember useful non-secret facts, configure local Agent state, use read-only connected-host/operator routes, and take safe non-destructive actions without spawning local agents or WRFC.',
+  '- GoodVibes Agent connects to a GoodVibes host owned outside this package. Do not start, stop, restart, install, expose, or mutate connected-host network/listener posture from Agent.',
   '- Use the `agent_local_registry` tool when a durable memory, reusable persona, skill, skill bundle, or routine would improve future work. Keep those records local, non-secret, source/provenance tagged, and reviewable. Review memory with a confidence score when it should shape future turns. Starting a routine means applying its steps in this same serial conversation, not creating a background job.',
   '- WRFC is never the default Agent reasoning path. Do not create local WRFC chains for planning, research, operations, knowledge, memory, configuration, approvals, automation observability, or ordinary assistant work.',
   '- GoodVibes Agent is not the coding TUI. Do not use the `agent` tool to spawn local Engineer, Reviewer, Tester, Verifier, or batch-spawn roots from Agent.',
@@ -130,7 +128,7 @@ export type BootstrapContext = RuntimeContext & {
  *   3. Tool registry + agent wiring
  *   4. Runtime bus subscriptions (WRFC, subagent, hook bridge)
  *   5. Providers, webhooks, PermissionManager, HookDispatcher
- *   6. Orchestrator + AcpManager
+ *   6. Orchestrator and Agent-local task read models
  *   7. MCP auto-connect + workspace/panel manager
  *   8. Command registry + plugin init + CommandContext
  *   9. Input handler wiring
@@ -183,7 +181,7 @@ export async function bootstrapRuntime(
     pluginManager,
   } = services;
 
-  // ── Phase 6: Orchestrator + AcpManager ───────────────────────────────────
+  // ── Phase 6: Orchestrator and Agent-local task read models ───────────────
 
   // Mutable function refs so main.ts can patch these after constructing the scroll/viewport state.
   // The orchestrator closes over these refs, so patching them in main.ts takes immediate effect.
@@ -243,17 +241,6 @@ export async function bootstrapRuntime(
   });
   conversation.setSessionLineageTracker(services.sessionLineageTracker);
 
-  const acpManager = new AcpManager({
-    requestPermission: (request) => permissionPromptRef.requestPermission(request),
-    runtimeBus,
-    hookDispatcher: services.hookDispatcher,
-  });
-  const acpTaskAdapter = new AcpTaskAdapter(store);
-  const ACP_TASK_SYNC_INTERVAL_MS = 1_000;
-  const acpTaskSyncInterval = setInterval(() => {
-    acpTaskAdapter.sync(acpManager);
-  }, ACP_TASK_SYNC_INTERVAL_MS);
-  bootstrapUnsubs.push(() => clearInterval(acpTaskSyncInterval));
   const opsTaskManager = createTaskManager(store, runtimeBus, userSessionId);
   const opsControlPlane = services.featureFlags.isEnabled('operator-control-plane')
     ? new OpsControlPlane(opsTaskManager, runtimeBus, store, userSessionId)
@@ -334,7 +321,7 @@ export async function bootstrapRuntime(
       port,
       baseUrl: formatHostServiceBaseUrl(host, port),
       reason: service === 'daemon'
-        ? 'GoodVibes Agent connects to GoodVibes services owned outside this product and does not start or restart them.'
+        ? 'GoodVibes Agent connects to a GoodVibes host owned outside this product and does not start or restart them.'
         : 'GoodVibes Agent does not own listener lifecycle.',
     };
   };
@@ -375,7 +362,7 @@ export async function bootstrapRuntime(
         daemonStatus: createExternalAgentServiceStatus('daemon'),
         httpListenerStatus: createExternalAgentServiceStatus('httpListener'),
       };
-      systemMessageRouter.high('[Startup] GoodVibes Agent does not start or restart connected GoodVibes services. Start them from GoodVibes TUI or the owning host, then refresh status.');
+      systemMessageRouter.high('[Startup] GoodVibes Agent does not start or restart the connected GoodVibes host. Start it from GoodVibes TUI or the owning host, then refresh status.');
       requestRender();
       return inspectExternalServices();
     },
@@ -452,8 +439,8 @@ export async function bootstrapRuntime(
   });
   bootstrapUnsubs.push(() => mcpAutoReload.stop());
   if (configManager.get('automation.enabled')) {
-    logger.warn('Local automation startup is disabled in GoodVibes Agent; use connected-service observability instead.');
-    systemMessageRouter.low('[Startup] Local automation runners are disabled in GoodVibes Agent; use read-only automation observability or explicit connected-service actions.');
+    logger.warn('Local automation startup is disabled in GoodVibes Agent; use connected-host observability instead.');
+    systemMessageRouter.low('[Startup] Local automation runners are disabled in GoodVibes Agent; use read-only automation observability or explicit connected-host actions.');
   }
 
   // ── Phase 12: Session:start lifecycle hook ─────────────────────────────
@@ -554,12 +541,6 @@ export async function bootstrapRuntime(
     },
   };
 
-  // ── Phase 12b: Operator intervention wiring (feature-gated) ──────────────
-  // Keep service-owned control-plane state internal. GoodVibes Agent does not
-  // expose the local ops-control panel; operator control is surfaced
-  // through Agent-owned status, approvals, automation, and delegation flows.
-  ctx.commandContext.ops.acpManager = acpManager;
-
   // Wire exit from options if provided; otherwise main.ts binds the shell bridge.
   if (options?.exit) {
     ctx.commandContext.exit = options.exit;

package/src/runtime/connected-host-auth.ts

@@ -0,0 +1,42 @@
+import { existsSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+
+type JsonRecord = Record<string, unknown>;
+
+export interface ConnectedHostOperatorToken {
+  readonly path: string;
+  readonly present: boolean;
+  readonly token: string | null;
+  readonly error?: string;
+}
+
+function isRecord(value: unknown): value is JsonRecord {
+  return Boolean(value) && typeof value === 'object' && !Array.isArray(value);
+}
+
+export function connectedHostOperatorTokenPath(homeDirectory: string): string {
+  return join(homeDirectory, '.goodvibes', 'daemon', 'operator-tokens.json');
+}
+
+export function readConnectedHostOperatorToken(homeDirectory: string): ConnectedHostOperatorToken {
+  const path = connectedHostOperatorTokenPath(homeDirectory);
+  if (!existsSync(path)) return { path, present: false, token: null };
+  try {
+    const parsed = JSON.parse(readFileSync(path, 'utf-8')) as unknown;
+    const token = isRecord(parsed) && typeof parsed.token === 'string' && parsed.token.trim().length > 0
+      ? parsed.token
+      : null;
+    return { path, present: true, token };
+  } catch (error) {
+    return { path, present: true, token: null, error: error instanceof Error ? error.message : String(error) };
+  }
+}
+
+export function connectedHostTokenRequiredMessage(path: string): string {
+  return [
+    'Connected-host operator token is required.',
+    `  token path: ${path}`,
+    '  Agent does not create or rotate connected-host auth tokens.',
+    '  Start or repair the owning GoodVibes host, then rerun this command.',
+  ].join('\n');
+}

package/src/runtime/diagnostics/panels/panel-resources.ts

@@ -1,7 +1,7 @@
 /**
  * Panel resource diagnostics panel data provider.
  *
- * Polls the shared TUI-owned ComponentHealthMonitor and produces PanelResourceSnapshot
+ * Polls the shared shell ComponentHealthMonitor and produces PanelResourceSnapshot
  * values for the diagnostics panel to render.
  */
 import type { ComponentHealthMonitor } from '../../perf/panel-health-monitor.ts';

package/src/runtime/index.ts

@@ -97,7 +97,6 @@ export const restoreRuntimeModel = bootstrap.restoreRuntimeModel;
 export const restoreSavedModel = bootstrap.restoreRuntimeModel;
 export const synchronizeConfiguredServices = bootstrap.synchronizeConfiguredServices;
 export const syncConfiguredServices = bootstrap.synchronizeConfiguredServices;
-export const registerBootstrapRuntimeEvents = bootstrap.registerBootstrapRuntimeEvents;
 export const registerHostRuntimeEvents = bootstrap.registerHostRuntimeEvents;
 function agentExternalHostStatus(
   config: Bootstrap.HostServicesConfig,
@@ -113,7 +112,7 @@ function agentExternalHostStatus(
     port,
     baseUrl: `http://${host}:${port}`,
     reason: service === 'daemon'
-      ? 'GoodVibes Agent connects to GoodVibes services owned outside this product and does not start or restart them.'
+      ? 'GoodVibes Agent connects to a GoodVibes host owned outside this product and does not start or restart them.'
       : 'GoodVibes Agent does not own listener lifecycle.',
   };
 }
@@ -245,7 +244,6 @@ export type RemoteRuntimeEvents = Transport.RemoteRuntimeEvents;
 export type SerializedRuntimeEnvelope = Transport.SerializedRuntimeEnvelope;
 
 // Operations compatibility aliases.
-export const AcpTaskAdapter = operations.AcpTaskAdapter;
 export const OpsControlPlane = operations.OpsControlPlane;
 export const OpsIllegalActionError = operations.OpsIllegalActionError;
 export const OpsTargetNotFoundError = operations.OpsTargetNotFoundError;
@@ -436,7 +434,6 @@ export const uninstallEcosystemCatalogEntry = shell.uninstallEcosystemCatalogEnt
 export const updateInstalledEcosystemEntry = shell.updateInstalledEcosystemEntry;
 export const upsertEcosystemCatalogEntry = shell.upsertEcosystemCatalogEntry;
 export const summarizeWorktreeOwnership = shell.summarizeWorktreeOwnership;
-export const WorktreeRegistry = shell.WorktreeRegistry;
 export const listPersistedWorktreeMeta = shell.listPersistedWorktreeMeta;
 export const getPersistedWorktreeMeta = shell.getPersistedWorktreeMeta;
 export const reviewWorktreeAttachments = shell.reviewWorktreeAttachments;
@@ -458,7 +455,6 @@ export type WorktreeRegistry = Shell.WorktreeRegistry;
 export type WorktreeStatusRecord = Shell.WorktreeStatusRecord;
 export type ManagedWorktreeMeta = Shell.ManagedWorktreeMeta;
 export type ShellAgentManagerService = Shell.ShellAgentManagerService;
-export type ShellAcpManagerService = Shell.ShellAcpManagerService;
 export type ShellAutomationManagerService = Shell.ShellAutomationManagerService;
 export type ShellAutomationManagerRuntimeService = Shell.ShellAutomationManagerRuntimeService;
 export type ShellModeManagerService = Shell.ShellModeManagerService;