@pellux/goodvibes-agent 0.1.116 → 1.0.0

package/src/runtime/bootstrap-core.ts

@@ -26,12 +26,21 @@ 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 { registerAgentChannelSendTool } from '../tools/agent-channel-send-tool.ts';
+import { registerAgentKnowledgeIngestTool } from '../tools/agent-knowledge-ingest-tool.ts';
+import { registerAgentKnowledgeTool } from '../tools/agent-knowledge-tool.ts';
 import { registerAgentLocalRegistryTool } from '../tools/agent-local-registry-tool.ts';
+import { registerAgentMediaGenerateTool } from '../tools/agent-media-generate-tool.ts';
+import { registerAgentNotifyTool } from '../tools/agent-notify-tool.ts';
+import { registerAgentOperatorActionTool } from '../tools/agent-operator-action-tool.ts';
+import { registerAgentOperatorBriefingTool } from '../tools/agent-operator-briefing-tool.ts';
+import { registerAgentReminderScheduleTool } from '../tools/agent-reminder-schedule-tool.ts';
+import { registerAgentWorkPlanTool } from '../tools/agent-work-plan-tool.ts';
 import { GOODVIBES_AGENT_SURFACE_ROOT } from '../config/surface.ts';
+import { registerAgentRuntimeEvents } from './agent-runtime-events.ts';
 
 export interface BootstrapCoreState {
   readonly userSessionId: string;
@@ -139,7 +148,7 @@ export async function initializeBootstrapCore(
     metadata: {
       product: 'goodvibes-agent',
       surfaceRoot: GOODVIBES_AGENT_SURFACE_ROOT,
-      clientKindNote: 'SDK has no dedicated agent client kind yet; using service for the Agent operator surface.',
+      clientKindNote: 'SDK compatibility client kind; GoodVibes Agent remains an interactive operator TUI.',
     },
   }, 'bootstrap.control-plane');
 
@@ -211,7 +220,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,
@@ -228,7 +236,16 @@ export async function initializeBootstrapCore(
     overflowHandler: services.overflowHandler,
     changeTracker: services.sessionChangeTracker,
   });
+  registerAgentKnowledgeIngestTool(toolRegistry, services.shellPaths, configManager);
+  registerAgentChannelSendTool(toolRegistry, services.channelDeliveryRouter);
+  registerAgentKnowledgeTool(toolRegistry, services.shellPaths, configManager);
   registerAgentLocalRegistryTool(toolRegistry, services.shellPaths, services.memoryRegistry);
+  registerAgentMediaGenerateTool(toolRegistry, services.mediaProviders, services.artifactStore);
+  registerAgentNotifyTool(toolRegistry, configManager, services.webhookNotifier);
+  registerAgentOperatorActionTool(toolRegistry, services.shellPaths, configManager);
+  registerAgentOperatorBriefingTool(toolRegistry, services.shellPaths, configManager);
+  registerAgentReminderScheduleTool(toolRegistry, services.shellPaths, configManager);
+  registerAgentWorkPlanTool(toolRegistry, services.workPlanStore);
   installAgentToolPolicyGuard(toolRegistry, {
     getLastUserMessage: () => conversation.getLastUserMessage(),
   });
@@ -314,7 +331,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 +339,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-hook-bridge.ts

@@ -10,9 +10,9 @@ import type { ConfigManager } from '@pellux/goodvibes-sdk/platform/config';
 import { formatReturnContextForDisplay, getReturnContextMode, maybeAssistReturnContextSummary } from '@/runtime/index.ts';
 import type { SharedSessionBroker } from '@pellux/goodvibes-sdk/platform/control-plane';
 import type { SessionManager } from '@pellux/goodvibes-sdk/platform/sessions';
-import type { PanelManager } from '../panels/panel-manager.ts';
 import type { ProviderRegistry } from '@pellux/goodvibes-sdk/platform/providers';
 import { summarizeError } from '@pellux/goodvibes-sdk/platform/utils';
+import { readConversationMessageSnapshots } from '../core/conversation-message-snapshot.ts';
 
 export interface ResumeSessionOptions {
   readonly runtimeBus: RuntimeEventBus;
@@ -24,7 +24,6 @@ export interface ResumeSessionOptions {
   readonly writeLastSessionPointer: (sessionId: string) => void;
   readonly hookDispatcher: HookDispatcher;
   readonly sessionManager: SessionManager;
-  readonly panelManager: PanelManager;
   readonly configManager: Pick<ConfigManager, 'get' | 'getCategory'>;
   readonly providerRegistry: Pick<ProviderRegistry, 'get' | 'getCurrentModel' | 'getForModel' | 'require'>;
 }
@@ -42,7 +41,7 @@ export function createResumeSessionHandler(options: ResumeSessionOptions): (sess
         turnCount: messages.length,
       });
       options.conversation.fromJSON({
-        messages: messages as Parameters<typeof options.conversation.fromJSON>[0]['messages'],
+        messages: readConversationMessageSnapshots(messages),
         title: meta.title,
         titleSource: meta.titleSource,
       });
@@ -53,28 +52,18 @@ export function createResumeSessionHandler(options: ResumeSessionOptions): (sess
       options.writeLastSessionPointer(sessionId);
       void options.sharedSessionBroker.reopenSession(sessionId).catch((err) => { logger.debug('session broker reopen session failed', { err }); });
       options.conversation.log(`Resumed session: ${sessionId}`, { fg: '135' });
-      const reopenedPanels: string[] = [];
-      if (meta.returnContext?.openPanels?.length) {
-        for (const panelId of meta.returnContext.openPanels.slice(0, 4)) {
-          try {
-            options.panelManager.open(panelId);
-            reopenedPanels.push(panelId);
-          } catch {
-            // Ignore unavailable panels during restore.
-          }
-        }
-        if (reopenedPanels.length > 0) options.panelManager.show();
-      }
+      const ignoredPanels = meta.returnContext?.openPanels?.slice(0, 4) ?? [];
       const returnContextMode = getReturnContextMode(options.configManager);
       if (returnContextMode !== 'off' && meta.returnContext) {
         for (const line of formatReturnContextForDisplay(meta.returnContext)) {
+          if (line.startsWith('Open panels:')) continue;
           options.conversation.log(`Resume: ${line}`, { fg: '244' });
         }
-        if (reopenedPanels.length > 0) {
-          options.conversation.log(`Resume: Reopened panels: ${reopenedPanels.join(', ')}`, { fg: '244' });
+        if (ignoredPanels.length > 0) {
+          options.conversation.log(`Resume: Saved panel state ignored: ${ignoredPanels.join(', ')}. Open the Agent workspace for current operator controls.`, { fg: '244' });
         }
         if ((meta.returnContext.remoteRunners?.length ?? 0) > 0) {
-          options.conversation.log('Resume: Remote runner recovery belongs outside Agent; delegate explicit build/fix/review recovery from Agent.', { fg: '244' });
+          options.conversation.log('Resume: Remote build-host recovery belongs outside Agent; delegate explicit build/fix/review recovery from Agent.', { fg: '244' });
         }
         if (returnContextMode === 'assisted') {
           const helperModel = new HelperModel({

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,
@@ -96,7 +133,6 @@ export function createBootstrapShell(options: BootstrapShellOptions): BootstrapS
     writeLastSessionPointer,
     hookDispatcher: services.hookDispatcher,
     sessionManager: services.sessionManager,
-    panelManager: services.panelManager,
     configManager,
     providerRegistry: services.providerRegistry,
   });
@@ -113,10 +149,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');
@@ -142,7 +179,7 @@ export function createBootstrapShell(options: BootstrapShellOptions): BootstrapS
     hookActivityTracker: services.hookActivityTracker,
     hookWorkbench: services.hookWorkbench,
     mcpRegistry: services.mcpRegistry,
-    daemonHomeDir: join(services.homeDirectory, '.goodvibes', 'daemon'),
+    connectedHostTokenDir: join(services.homeDirectory, '.goodvibes', 'daemon'),
   });
   services.panelManager.prewarmRegistered();
 
@@ -160,9 +197,8 @@ export function createBootstrapShell(options: BootstrapShellOptions): BootstrapS
 
   const commandRegistry = new CommandRegistry();
   registerBuiltinCommands(commandRegistry);
-  type RuntimeFoundationInput = Parameters<typeof createRuntimeFoundationClients>[0];
   const foundationClients = createRuntimeFoundationClients({
-    runtimeServices: services as unknown as RuntimeFoundationInput['runtimeServices'],
+    runtimeServices: services,
     tasksReadModel: uiServices.readModels.tasks,
     taskManager,
     opsControlPlane,
@@ -198,6 +234,8 @@ export function createBootstrapShell(options: BootstrapShellOptions): BootstrapS
     voiceProviderRegistry: services.voiceProviders,
     voiceService: services.voiceService,
     mediaProviderRegistry: services.mediaProviders,
+    artifactStore: services.artifactStore,
+    channelDeliveryRouter: services.channelDeliveryRouter,
     forensicsRegistry,
     policyRuntimeState,
     readModels: uiServices.readModels,

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,14 +45,23 @@ 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.',
-  '- 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.',
-  '- When the user explicitly asks to build, implement, fix, patch, or review code, preserve the full original user ask and delegate one build request to GoodVibes TUI through the public shared-session/build-delegation contract. Include clear executionIntent and request WRFC only for explicit build/fix/review work or when the user explicitly asks for WRFC/agent review.',
-  '- Do not narrow explicit build/fix/review requests into design-only, read-only, or no-write work unless the user explicitly requested that limitation. TUI owns file edits, git/worktree work, execution isolation UX, and the WRFC owner chain.',
-  '- If a stable public delegation route is unavailable, say that the task needs GoodVibes TUI delegation and report the missing route instead of pretending to implement it locally or spawning sibling local agents.',
+  '- Default to serial, proactive assistant work in the main conversation. Answer, inspect, summarize, remember useful non-secret facts, configure Agent-local state, use read-only connected-host/operator routes, and take safe non-destructive actions without creating separate Agent jobs or GoodVibes TUI delegations.',
+  '- 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_operator_briefing` tool for read-only main-conversation summaries of connected work plan, approvals, automation, schedules, and scheduler capacity. This tool must not call mutation routes, connected-host lifecycle routes, default knowledge, non-Agent knowledge spaces, separate Agent job creation, or GoodVibes TUI delegation.',
+  '- When the user explicitly asks Agent to approve, deny, or cancel a specific approval, run/pause/resume a specific automation job, cancel/retry a specific automation run, or run a specific schedule, use the `agent_operator_action` tool with confirm:true and the original user request. It can call only its allowlisted public operator routes and must not create, edit, delete, or discover automation definitions.',
+  '- Use the `agent_work_plan` tool to keep the visible Agent-local work plan current while working in the main conversation. Create, inspect, and update local work items proactively when useful. Removing items or clearing completed items requires an explicit user request and confirm:true.',
+  '- Use the `agent_knowledge` tool for Agent Knowledge status, ask, and search from the main conversation. It must use only /api/goodvibes-agent/knowledge/* and must fail closed instead of falling back to default knowledge or non-Agent knowledge spaces.',
+  '- When the user explicitly asks Agent to add, import, remember, or ingest a URL, URL-list file, local file, bookmarks file, browser history, or connector input into Agent Knowledge, use the `agent_knowledge_ingest` tool with confirm:true and the original user request. It must write only to /api/goodvibes-agent/knowledge/* ingest routes and never to default knowledge or non-Agent knowledge spaces.',
+  '- Use the `agent_local_registry` tool when a scratchpad note, durable memory, reusable persona, skill, skill bundle, or routine would improve later work. Keep those records Agent-local, non-secret, source/provenance tagged, and reviewable. Notes are for temporary/source-triage context; promote them explicitly into memory, skills, personas, routines, or Agent Knowledge only when that is the correct durable home. Review memory with a confidence score when it should shape later turns. Starting a routine means applying its steps in this same serial conversation, not creating a background job.',
+  '- When the user explicitly asks Agent to generate an image, video, or other media artifact, use the `agent_media_generate` tool with confirm:true and the original user request. Generated media is stored as artifacts; do not print base64, call default knowledge, use non-Agent knowledge spaces, send channels, create separate Agent jobs, or request GoodVibes TUI delegation for media generation.',
+  '- When the user explicitly asks Agent to send an alert, message, or notification to configured notification targets, use the `agent_notify` tool with confirm:true and the original user request. Do not infer external notifications from vague suggestions, and never create channel routes or account authorizations from the main conversation.',
+  '- When the user explicitly asks Agent to send one message to a specific configured channel, route, webhook, or link target, use the `agent_channel_send` tool with confirm:true and the original user request. It can deliver one message through configured delivery strategies, but must not create routes, authorize accounts, manage connected-host hosting, use default knowledge, use non-Agent knowledge spaces, create separate Agent jobs, or request GoodVibes TUI delegation.',
+  '- When the user explicitly asks for a reminder or asks Agent to schedule a reminder, use the `agent_reminder_schedule` tool with confirm:true and the original user request. That creates one connected schedules.create reminder on the external GoodVibes host. Do not infer reminders from vague suggestions or routine startup, and never create local scheduler jobs.',
+  '- GoodVibes TUI delegation is never the default Agent reasoning path. Do not delegate 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 create coding-role Agent jobs or batch job roots from Agent.',
+  '- When the user explicitly asks to build, implement, fix, patch, or review code, preserve the full original user ask and delegate one build request to GoodVibes TUI through the public shared-session/build-delegation contract. Include clear executionIntent and request delegated review only for explicit build/fix/review work or when the user explicitly asks for delegated Agent review.',
+  '- Do not narrow explicit build/fix/review requests into design-only, read-only, or no-write work unless the user explicitly requested that limitation. TUI owns file edits, git/worktree work, execution isolation UX, and delegated review coordination.',
+  '- If a stable public delegation route is unavailable, say that the task needs GoodVibes TUI delegation and report the missing route instead of pretending to implement it locally or creating sibling Agent jobs.',
 ].join('\n');
 
 function joinPromptParts(...parts: Array<string | null | undefined>): string {
@@ -128,9 +135,9 @@ export type BootstrapContext = RuntimeContext & {
  *   1. Config, caches, keybindings
  *   2. Runtime event bus, conversation, compositor, selection
  *   3. Tool registry + agent wiring
- *   4. Runtime bus subscriptions (WRFC, subagent, hook bridge)
+ *   4. Runtime bus subscriptions (delegation, 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 +190,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 +250,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)
@@ -308,7 +304,7 @@ export async function bootstrapRuntime(
     },
   };
 
-  // ── Phase 7: External services + deferred startup ──────────────────────
+  // ── Phase 7: Connected-host posture + deferred startup ────────────────
 
   const deferredStartup = createDeferredStartupCoordinator();
 
@@ -323,7 +319,7 @@ export async function bootstrapRuntime(
     return `http://${urlHost}:${port}`;
   };
 
-  const createExternalAgentServiceStatus = (
+  const createAgentDependencyStatus = (
     service: 'daemon' | 'httpListener',
   ): HostServiceStatus => {
     const host = String(configManager.get(service === 'daemon' ? 'controlPlane.host' : 'httpListener.host') ?? '127.0.0.1');
@@ -334,7 +330,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 it.'
         : 'GoodVibes Agent does not own listener lifecycle.',
     };
   };
@@ -343,15 +339,15 @@ export async function bootstrapRuntime(
 
   const hostServiceIsBlocked = (status: HostServiceStatus): boolean => status.mode === 'blocked';
 
-  const inspectExternalServices = () => {
+  const inspectAgentDependencies = () => {
     const daemonStatus = externalServices.daemonStatus;
     const httpListenerStatus = externalServices.httpListenerStatus;
     return {
-      daemonRunning: hostServiceIsActive(daemonStatus),
-      daemonPortInUse: hostServiceIsBlocked(daemonStatus),
+      connectedHostRunning: hostServiceIsActive(daemonStatus),
+      connectedHostPortInUse: hostServiceIsBlocked(daemonStatus),
       httpListenerRunning: hostServiceIsActive(httpListenerStatus),
       httpListenerPortInUse: hostServiceIsBlocked(httpListenerStatus),
-      daemonStatus,
+      connectedHostStatus: daemonStatus,
       httpListenerStatus,
     };
   };
@@ -359,8 +355,8 @@ export async function bootstrapRuntime(
   let externalServices: ExternalServicesHandle = {
     daemonServer: null,
     httpListener: null,
-    daemonStatus: createExternalAgentServiceStatus('daemon'),
-    httpListenerStatus: createExternalAgentServiceStatus('httpListener'),
+    daemonStatus: createAgentDependencyStatus('daemon'),
+    httpListenerStatus: createAgentDependencyStatus('httpListener'),
     listRecentControlPlaneEvents: () => [],
     async stop(): Promise<void> {},
   };
@@ -368,16 +364,16 @@ export async function bootstrapRuntime(
     externalServices: NonNullable<typeof uiServices.platform.externalServices>;
   };
   platformExternalServices.externalServices = {
-    inspect: inspectExternalServices,
+    inspect: inspectAgentDependencies,
     restart: async () => {
       externalServices = {
         ...externalServices,
-        daemonStatus: createExternalAgentServiceStatus('daemon'),
-        httpListenerStatus: createExternalAgentServiceStatus('httpListener'),
+        daemonStatus: createAgentDependencyStatus('daemon'),
+        httpListenerStatus: createAgentDependencyStatus('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();
+      return inspectAgentDependencies();
     },
   };
   deferredStartup.schedule({
@@ -452,8 +448,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 execution is disabled in GoodVibes Agent; use read-only automation observability or explicit connected-host actions.');
   }
 
   // ── Phase 12: Session:start lifecycle hook ─────────────────────────────
@@ -554,12 +550,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,47 @@
+import { createHash } from 'node:crypto';
+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 connectedHostOperatorTokenFingerprint(token: string): string {
+  return createHash('sha256').update(token).digest('hex').slice(0, 12);
+}
+
+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.',
+    '  Provision or repair connected-host access through the owning GoodVibes host, then rerun this command.',
+  ].join('\n');
+}

package/src/runtime/diagnostics/panels/index.ts

@@ -12,8 +12,8 @@ export type { InspectableDomain } from '@/runtime/index.ts';
 export { HealthPanel } from '@/runtime/index.ts';
 export { DivergencePanel } from '@/runtime/index.ts';
 export { ReplayPanel } from '@/runtime/index.ts';
-export { PolicyPanel } from './policy.ts';
-export type { PolicyPanelSnapshot } from './policy.ts';
+export { PolicyDiagnosticsPanel } from './policy.ts';
+export type { PolicyDiagnosticsSnapshot } from './policy.ts';
 export { ToolContractsPanel } from '@/runtime/index.ts';
 export { TransportPanel } from '@/runtime/index.ts';
 export type { TransportPanelSnapshot } from '@/runtime/index.ts';

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/diagnostics/panels/policy.ts

@@ -1,5 +1,5 @@
 /**
- * Policy diagnostics panel data provider.
+ * Policy diagnostics data provider.
  *
  * Wraps a `PolicyRegistry` and optionally a `DivergencePanel` to expose
  * combined policy state (current bundle, candidate, simulation status,
@@ -24,7 +24,7 @@ import { logger } from '@pellux/goodvibes-sdk/platform/utils';
 /**
  * A point-in-time snapshot of policy state for diagnostics rendering.
  */
-export interface PolicyPanelSnapshot {
+export interface PolicyDiagnosticsSnapshot {
   /** The currently enforced bundle, or null if no policy is active. */
   current: PolicyBundleVersion | null;
   /** The pending candidate bundle, or null if none loaded. */
@@ -48,12 +48,12 @@ export interface PolicyPanelSnapshot {
 }
 
 /**
- * PolicyPanel — diagnostics data provider for the policy registry.
+ * PolicyDiagnosticsPanel — diagnostics data provider for the policy registry.
  *
  * Usage:
  * ```ts
  * const registry = new PolicyRegistry();
- * const panel = new PolicyPanel(registry, divergencePanel);
+ * const panel = new PolicyDiagnosticsPanel(registry, divergencePanel);
  *
  * panel.subscribe(() => {
  *   const snap = panel.getSnapshot();
@@ -67,7 +67,7 @@ export interface PolicyPanelSnapshot {
  * panel.dispose();
  * ```
  */
-export class PolicyPanel {
+export class PolicyDiagnosticsPanel {
   private readonly _registry: PolicyRegistry;
   private readonly _divergencePanel: DivergencePanel | null;
   private readonly _config: PanelConfig;
@@ -118,7 +118,7 @@ export class PolicyPanel {
   /**
    * getSnapshot — Returns the current combined policy + divergence snapshot.
    */
-  public getSnapshot(): PolicyPanelSnapshot {
+  public getSnapshot(): PolicyDiagnosticsSnapshot {
     const current = this._registry.getCurrent();
     const candidate = this._registry.getCandidate();
     const rawHistory = this._registry.getHistory();
@@ -170,7 +170,7 @@ export class PolicyPanel {
       try {
         cb();
       } catch (err) {
-        logger.warn(`[PolicyPanel] subscriber error: ${err}`);
+        logger.warn(`[PolicyDiagnosticsPanel] subscriber error: ${err}`);
       }
     }
   }