@pellux/goodvibes-agent 0.1.104 → 0.1.106

package/src/input/onboarding/onboarding-wizard-steps.ts

@@ -1,9 +1,10 @@
 import { REASONING_OPTIONS, HITL_MODE_OPTIONS, GUIDANCE_MODE_OPTIONS, PERMISSION_MODE_OPTIONS, SECRET_POLICY_OPTIONS } from './onboarding-wizard-constants.ts';
 import { modelSelectionLabel, normalizeText } from './onboarding-wizard-helpers.ts';
+import { buildAgentKnowledgeStep, buildAutomationStep, buildCommunicationStep, buildDelegationPolicyStep, buildLocalStateStep, buildToolsStep, buildVoiceMediaStep } from './onboarding-wizard-operator-steps.ts';
 import { listAgentRuntimeProfileTemplates } from '../../agent/runtime-profile.ts';
 import type { OnboardingWizardController } from './onboarding-wizard.ts';
 import type { OnboardingWizardActionFieldDefinition, OnboardingWizardFieldDefinition, OnboardingWizardModelPickerFieldDefinition, OnboardingWizardRadioFieldDefinition, OnboardingWizardRadioOption, OnboardingWizardStepDefinition } from './onboarding-wizard-types.ts';
-import type { OnboardingStep1CapabilityId, OnboardingStep1CapabilityItem } from '../../runtime/onboarding/index.ts';
+import type { OnboardingProviderAccountRecord, OnboardingStep1CapabilityId, OnboardingStep1CapabilityItem } from '../../runtime/onboarding/index.ts';
 
 function buildStarterTemplateOptions(): readonly OnboardingWizardRadioOption[] {
   return [
@@ -82,6 +83,27 @@ function profileSetupLabel(controller: OnboardingWizardController): string {
   return templateId === 'none' ? `Create ${profileName}` : `Create ${profileName} from ${templateId}`;
 }
 
+function formatBoundedList(values: readonly string[], empty: string): string {
+  const unique = [...new Set(values.map((value) => value.trim()).filter((value) => value.length > 0))]
+    .sort((left, right) => left.localeCompare(right));
+  if (unique.length === 0) return empty;
+  if (unique.length <= 4) return unique.join(', ');
+  return `${unique.slice(0, 4).join(', ')} +${unique.length - 4} more`;
+}
+
+function providerAccountLabel(provider: OnboardingProviderAccountRecord): string {
+  const route = provider.activeRoute && provider.activeRoute !== 'unconfigured'
+    ? provider.activeRoute
+    : provider.oauthReady
+      ? 'oauth-ready'
+      : provider.pendingLogin
+        ? 'pending-login'
+        : provider.configured
+          ? 'configured'
+          : 'unconfigured';
+  return `${provider.providerId}:${route}`;
+}
+
 function buildReviewReadinessFields(controller: OnboardingWizardController): readonly OnboardingWizardFieldDefinition[] {
   const localBehavior = findRuntimeCapability(controller, 'local-behavior');
   const channels = findRuntimeCapability(controller, 'communication-channels');
@@ -151,96 +173,6 @@ function buildReviewReadinessFields(controller: OnboardingWizardController): rea
   ];
 }
 
-export function buildCommunicationStep(): OnboardingWizardStepDefinition {
-  return {
-    id: 'agent-communication',
-    title: 'Channels and notifications',
-    shortLabel: 'Channels',
-    description: 'Prepare the Agent for companion pairing, messaging-channel awareness, notification delivery, and safe outbound communication while leaving runtime hosting external.',
-    summaryTitle: 'Communication posture',
-    summaryLines: [
-      'Companion chat: paired through the GoodVibes runtime',
-      'Channel accounts: inspect readiness before using them',
-      'Outbound messages: explicit user action only',
-    ],
-    fields: [
-      {
-        kind: 'status',
-        id: 'agent-communication.companion',
-        label: 'Companion pairing',
-        hint: 'Use /pair from the Agent workspace to pair companion clients through the already-running GoodVibes runtime.',
-        defaultValue: 'External runtime route',
-      },
-      {
-        kind: 'status',
-        id: 'agent-communication.channels',
-        label: 'Messaging channels',
-        hint: 'Use the Channels workspace to inspect account readiness, delivery posture, and recent communication without changing runtime hosting.',
-        defaultValue: 'Inspectable',
-      },
-      {
-        kind: 'status',
-        id: 'agent-communication.notifications',
-        label: 'Notification delivery',
-        hint: 'Routine, approval, and work-plan notifications require an explicit delivery target and command; Agent never silently sends external messages.',
-        defaultValue: 'Explicit only',
-      },
-      {
-        kind: 'status',
-        id: 'agent-communication.inbound-policy',
-        label: 'Inbound command policy',
-        hint: 'Incoming channel commands stay constrained by runtime policy, allowlists, and account posture.',
-        defaultValue: 'Policy gated',
-      },
-    ],
-  };
-}
-
-export function buildToolsStep(): OnboardingWizardStepDefinition {
-  return {
-    id: 'agent-tools',
-    title: 'Tools and MCP',
-    shortLabel: 'Tools',
-    description: 'Review tool access for the Agent operator: MCP servers, browser/media helpers, safe read-only inspection, and explicit approval before side effects.',
-    summaryTitle: 'Tool posture',
-    summaryLines: [
-      'MCP and tools: inspect before use',
-      'Read/search/summarize: safe by default',
-      'Writes, installs, external sends, and account changes: require explicit user action',
-    ],
-    fields: [
-      {
-        kind: 'status',
-        id: 'agent-tools.mcp',
-        label: 'MCP servers and tools',
-        hint: 'Use /mcp servers and the Agent workspace Tools area to inspect connected servers, roles, and tool readiness.',
-        defaultValue: 'Inspectable',
-      },
-      {
-        kind: 'status',
-        id: 'agent-tools.browser-media',
-        label: 'Browser and media helpers',
-        hint: 'Browser, image, audio, and file helpers are task-scoped tools. Agent uses them only when the current task needs them and policy allows it.',
-        defaultValue: 'Task scoped',
-      },
-      {
-        kind: 'status',
-        id: 'agent-tools.approval-boundary',
-        label: 'Power action boundary',
-        hint: 'Workspace writes, package installs, external sends, and account changes require an explicit command or confirmation.',
-        defaultValue: 'Approval required',
-      },
-      {
-        kind: 'status',
-        id: 'agent-tools.no-hidden-work',
-        label: 'Hidden work policy',
-        hint: 'Tool use stays visible in the main Agent conversation or explicit command workspace; no hidden background work is started from onboarding.',
-        defaultValue: 'Visible',
-      },
-    ],
-  };
-}
-
 export function buildLoadingStep(controller: OnboardingWizardController): OnboardingWizardStepDefinition {
   const failed = controller.hydrationError !== null;
   return {
@@ -342,17 +274,42 @@ export function buildProviderAccessStep(controller: OnboardingWizardController):
   const openAiPending = pendingSubscriptions.some((subscription) => subscription.provider === 'openai');
   const providerSecretCount = controller.runtimeSnapshot?.secrets.records.filter((record) => record.key.endsWith('_API_KEY') || record.key.endsWith('_TOKEN')).length ?? 0;
   const openAiApiKeyConfigured = controller.runtimeSnapshot?.secrets.records.some((record) => record.key === 'OPENAI_API_KEY') ?? false;
+  const routing = controller.runtimeSnapshot?.providerRouting;
+  const accountProviders = controller.runtimeSnapshot?.providerAccounts?.providers ?? [];
+  const configuredAccounts = accountProviders.filter((provider) =>
+    provider.configured || provider.active || provider.oauthReady || provider.pendingLogin || provider.activeRoute !== 'unconfigured',
+  );
+  const providerRouteLabel = routing
+    ? `${routing.primaryProviderId}/${routing.primaryModelId}`
+    : 'Not loaded';
+  const activeSubscriptionProviders = activeSubscriptions.map((subscription) => subscription.provider);
+  const pendingSubscriptionProviders = pendingSubscriptions.map((subscription) => subscription.provider);
   const fields: OnboardingWizardFieldDefinition[] = [
     {
       kind: 'status',
-      id: 'providers.openai-subscription',
-      label: 'OpenAI subscription status',
-      hint: openAiActive
-        ? 'An OpenAI subscription session is already available.'
-        : openAiPending
-          ? 'An OpenAI subscription login is pending.'
-          : 'No OpenAI subscription session was found in the current Agent state.',
-      defaultValue: openAiActive ? 'Active' : openAiPending ? 'Pending' : 'Not detected',
+      id: 'providers.default-route',
+      label: 'Current conversation route',
+      hint: 'Normal Agent turns use this provider/model until you change the default model route.',
+      defaultValue: providerRouteLabel,
+    },
+    {
+      kind: 'status',
+      id: 'providers.account-routes',
+      label: 'Provider account routes',
+      hint: configuredAccounts.length > 0
+        ? formatBoundedList(configuredAccounts.map(providerAccountLabel), 'No provider account routes detected.')
+        : 'No provider account routes were detected in the current Agent state.',
+      defaultValue: configuredAccounts.length > 0 ? `${configuredAccounts.length} route(s)` : 'None detected',
+    },
+    {
+      kind: 'status',
+      id: 'providers.subscription-sessions',
+      label: 'Subscription sessions',
+      hint: [
+        `active: ${formatBoundedList(activeSubscriptionProviders, 'none')}`,
+        `pending: ${formatBoundedList(pendingSubscriptionProviders, 'none')}`,
+      ].join('  '),
+      defaultValue: `${activeSubscriptions.length} active / ${pendingSubscriptions.length} pending`,
     },
     {
       kind: 'status',
@@ -364,10 +321,10 @@ export function buildProviderAccessStep(controller: OnboardingWizardController):
     {
       kind: 'masked',
       id: 'providers.openai-api-key',
-      label: 'OpenAI API key',
+      label: 'OpenAI API key quick start',
       hint: openAiApiKeyConfigured
-        ? 'An OpenAI API key is already stored. Leave blank to keep it; enter a new key to replace it through the secret manager.'
-        : 'Optional: enter an OpenAI API key now. The value is stored through the secret manager, not in config.',
+        ? 'Optional quick start: an OpenAI API key is already stored. Leave blank to keep it; enter a new key to replace it through the secret manager.'
+        : 'Optional quick start: enter an OpenAI API key now. Other providers can be configured from /secrets, /provider, and the model picker.',
       placeholder: openAiApiKeyConfigured ? 'already configured' : 'sk-...',
       defaultValue: '',
     },
@@ -413,11 +370,12 @@ export function buildProviderAccessStep(controller: OnboardingWizardController):
     id: 'provider-access',
     title: 'AI provider access',
     shortLabel: 'Providers',
-    description: 'Review provider access for the Agent conversation. Credentials stay masked and are stored through the secret manager.',
+    description: 'Review provider and model access for the Agent conversation. Credentials stay masked and provider-specific setup remains configurable.',
     summaryTitle: 'Provider access summary',
     summaryLines: [
-      `OpenAI subscription: ${openAiActive ? 'active' : openAiPending ? 'pending' : 'not detected'}`,
-      `OpenAI API key: ${openAiApiKeyConfigured ? 'configured' : 'not detected'}`,
+      `Default route: ${providerRouteLabel}`,
+      `Provider account routes: ${configuredAccounts.length}`,
+      `Subscription sessions: ${activeSubscriptions.length} active / ${pendingSubscriptions.length} pending`,
       `Provider credential references: ${providerSecretCount}`,
     ],
     fields,
@@ -461,210 +419,6 @@ export function buildDefaultModelStep(controller: OnboardingWizardController): O
   };
 }
 
-export function buildAgentKnowledgeStep(): OnboardingWizardStepDefinition {
-  return {
-    id: 'agent-knowledge',
-    title: 'Agent Knowledge',
-    shortLabel: 'Knowledge',
-    description: 'Agent Knowledge is isolated to the GoodVibes Agent product segment. It never falls back to default Knowledge/Wiki or any non-Agent product segment.',
-    summaryTitle: 'Knowledge isolation',
-    summaryLines: [
-      'Route segment: /api/goodvibes-agent/knowledge/*',
-      'Default wiki fallback: disabled',
-      'Non-Agent route fallback: disabled',
-    ],
-    fields: [
-      {
-        kind: 'status',
-        id: 'agent-knowledge.route',
-        label: 'Isolated Agent Knowledge route',
-        hint: 'Ask, search, status, and ingest use /api/goodvibes-agent/knowledge/* only.',
-        defaultValue: 'Isolated',
-      },
-      {
-        kind: 'status',
-        id: 'agent-knowledge.no-default-wiki',
-        label: 'Default Knowledge/Wiki fallback',
-        hint: 'Agent setup and Agent ask/search must not query the default wiki when Agent Knowledge has no answer.',
-        defaultValue: 'Blocked',
-      },
-      {
-        kind: 'status',
-        id: 'agent-knowledge.no-non-agent-routes',
-        label: 'Non-Agent route fallback',
-        hint: 'Other product routes are not part of Agent Knowledge.',
-        defaultValue: 'Blocked',
-      },
-    ],
-  };
-}
-
-export function buildLocalStateStep(): OnboardingWizardStepDefinition {
-  return {
-    id: 'agent-local-state',
-    title: 'Local memory and behavior',
-    shortLabel: 'Memory',
-    description: 'Review the Agent-local behavior model. Memory, personas, skills, routines, and Agent profiles stay local until a stable shared registry exists.',
-    summaryTitle: 'Local Agent state',
-    summaryLines: [
-      'Memory/personas/skills/routines: local Agent registries',
-      'Secrets: rejected or stored by secret reference',
-      'Profiles: isolated Agent homes',
-    ],
-    fields: [
-      {
-        kind: 'status',
-        id: 'agent-local-state.memory',
-        label: 'Local memory',
-        hint: 'Use /memory to create, review, stale, search, and delete Agent-local memory records.',
-        defaultValue: 'Local registry',
-      },
-      {
-        kind: 'status',
-        id: 'agent-local-state.personas',
-        label: 'Personas',
-        hint: 'Use /personas to create and activate serial operating modes for the main conversation.',
-        defaultValue: 'Local registry',
-      },
-      {
-        kind: 'status',
-        id: 'agent-local-state.skills',
-        label: 'Skills',
-        hint: 'Use /agent-skills and /skills local to manage reusable Agent procedures.',
-        defaultValue: 'Local registry',
-      },
-      {
-        kind: 'status',
-        id: 'agent-local-state.routines',
-        label: 'Routines',
-        hint: 'Use /routines for reusable local procedures. Starting a routine prints steps in the main conversation and does not spawn hidden work.',
-        defaultValue: 'Local registry',
-      },
-    ],
-  };
-}
-
-export function buildAutomationStep(): OnboardingWizardStepDefinition {
-  return {
-    id: 'agent-automation',
-    title: 'Routines and automation',
-    shortLabel: 'Routines',
-    description: 'Set the Agent automation posture: local routines run in the main conversation, while external schedules remain explicit.',
-    summaryTitle: 'Routine and schedule posture',
-    summaryLines: [
-      'Local routines: reusable main-conversation workflows',
-      'External schedules: explicit promotion only',
-      'Runs/cancels/retries: command-confirmed side effects',
-    ],
-    fields: [
-      {
-        kind: 'status',
-        id: 'agent-automation.local-routines',
-        label: 'Local routine library',
-        hint: 'Use /routines or the Agent workspace to create, review, enable, and start local routines without spawning hidden jobs.',
-        defaultValue: 'Local registry',
-      },
-      {
-        kind: 'status',
-        id: 'agent-automation.schedule-observability',
-        label: 'Schedule observability',
-        hint: 'Use /schedule list, /schedule reconcile, and automation views to inspect externally owned jobs and runs.',
-        defaultValue: 'Read first',
-      },
-      {
-        kind: 'status',
-        id: 'agent-automation.schedule-promotion',
-        label: 'Routine-to-schedule promotion',
-        hint: 'Creating external schedules from routines requires a reviewed routine, a real timing expression, optional delivery target, and explicit confirmation.',
-        defaultValue: 'Explicit command',
-      },
-      {
-        kind: 'status',
-        id: 'agent-automation.mutations',
-        label: 'Automation mutations',
-        hint: 'Run, pause, resume, cancel, retry, approve, and deny actions are never inferred from chat; they require exact commands and confirmation.',
-        defaultValue: 'Confirmed only',
-      },
-    ],
-  };
-}
-
-export function buildVoiceMediaStep(): OnboardingWizardStepDefinition {
-  return {
-    id: 'agent-voice-media',
-    title: 'Voice and media',
-    shortLabel: 'Voice',
-    description: 'Prepare voice, speech, image input, and media understanding as Agent operator tools rather than runtime lifecycle features.',
-    summaryTitle: 'Voice and media posture',
-    summaryLines: [
-      'Voice and speech: optional operator tools',
-      'Image/audio inputs: explicit attachment workflows',
-      'Media generation and playback: provider-backed and policy-gated',
-    ],
-    fields: [
-      {
-        kind: 'status',
-        id: 'agent-voice-media.voice',
-        label: 'Voice interaction',
-        hint: 'Use the voice/media workspace and TTS settings to configure spoken responses for the Agent conversation.',
-        defaultValue: 'Optional',
-      },
-      {
-        kind: 'status',
-        id: 'agent-voice-media.attachments',
-        label: 'Image and audio input',
-        hint: 'Attach files explicitly to a prompt or command. Agent does not ingest media into Knowledge without an Agent Knowledge ingest action.',
-        defaultValue: 'Explicit input',
-      },
-      {
-        kind: 'status',
-        id: 'agent-voice-media.output',
-        label: 'Generated media and playback',
-        hint: 'Media output uses configured providers and visible command/turn flow; external publication still requires explicit approval.',
-        defaultValue: 'Policy gated',
-      },
-    ],
-  };
-}
-
-export function buildDelegationPolicyStep(): OnboardingWizardStepDefinition {
-  return {
-    id: 'agent-delegation',
-    title: 'Build delegation',
-    shortLabel: 'Delegate',
-    description: 'GoodVibes Agent is not the coding TUI. Explicit build, fix, review, or implementation work is delegated to GoodVibes TUI; ordinary assistant work stays serial in this conversation.',
-    summaryTitle: 'Delegation policy',
-    summaryLines: [
-      'Normal chat: main Agent conversation',
-      'Build/fix/review: explicit GoodVibes TUI delegation',
-      'WRFC: only when explicitly requested for build/fix/review',
-    ],
-    fields: [
-      {
-        kind: 'status',
-        id: 'agent-delegation.normal-chat',
-        label: 'Normal assistant work',
-        hint: 'Planning, research, summaries, local memory updates, and safe read-only checks stay in the main Agent conversation.',
-        defaultValue: 'Serial',
-      },
-      {
-        kind: 'status',
-        id: 'agent-delegation.build-work',
-        label: 'Build/fix/review work',
-        hint: 'Use /delegate with the full original task. GoodVibes TUI owns coding execution and WRFC chains.',
-        defaultValue: 'Explicit delegation',
-      },
-      {
-        kind: 'status',
-        id: 'agent-delegation.wrfc',
-        label: 'WRFC policy',
-        hint: 'Agent never uses WRFC by default; request it only for explicit build, fix, review, or implementation work.',
-        defaultValue: 'Explicit only',
-      },
-    ],
-  };
-}
-
 export function buildExperienceStep(controller: OnboardingWizardController): OnboardingWizardStepDefinition {
   return {
     id: 'experience',

package/src/main.ts

@@ -289,7 +289,7 @@ async function main() {
     if (processedText.startsWith('!#')) {
       const memoryText = processedText.slice(2).trim();
       if (!memoryText) {
-        systemMessageRouter.high('[Memory] Usage: !# <text to pin as session memory>');
+        systemMessageRouter.high('[Memory] Usage: !# <text to pin as conversation-pinned memory>');
         render();
         processedText = '';
       } else {

package/src/panels/builtin/usage.ts

@@ -0,0 +1,21 @@
+import type { PanelManager } from '../panel-manager.ts';
+import { CostTrackerPanel } from '../cost-tracker-panel.ts';
+import type { ResolvedBuiltinPanelDeps } from './shared.ts';
+import { requireUiServices } from './shared.ts';
+
+export function registerUsagePanels(manager: PanelManager, deps: ResolvedBuiltinPanelDeps): void {
+  if (!deps.getOrchestratorUsage) return;
+
+  const { getOrchestratorUsage, budgetThreshold } = deps;
+  manager.registerType({
+    id: 'cost',
+    name: 'Cost',
+    icon: '$',
+    category: 'monitoring',
+    description: 'Estimated assistant usage costs for this session and explicit delegated work, with budget alerts',
+    factory: () => {
+      const ui = requireUiServices(deps);
+      return new CostTrackerPanel(ui.events.turns, ui.events.agents, getOrchestratorUsage, { budgetThreshold });
+    },
+  });
+}

package/src/panels/builtin-panels.ts

@@ -1,6 +1,6 @@
 import type { PanelManager } from './panel-manager.ts';
 import { resolveBuiltinPanelDeps, type BuiltinPanelDeps } from './builtin/shared.ts';
-import { registerDevelopmentPanels } from './builtin/development.ts';
+import { registerUsagePanels } from './builtin/usage.ts';
 import { registerOperationsPanels } from './builtin/operations.ts';
 import { registerAgentPanels } from './builtin/agent.ts';
 import { registerSessionPanels } from './builtin/session.ts';
@@ -13,7 +13,7 @@ import { registerKnowledgePanels } from './builtin/knowledge.ts';
  */
 export function registerBuiltinPanels(manager: PanelManager, deps: BuiltinPanelDeps): void {
   const resolved = resolveBuiltinPanelDeps(deps);
-  registerDevelopmentPanels(manager, resolved);
+  registerUsagePanels(manager, resolved);
   registerOperationsPanels(manager, resolved);
   registerAgentPanels(manager, resolved);
   registerSessionPanels(manager, resolved);

package/src/panels/panel-list-panel.ts

@@ -65,9 +65,8 @@ const C = {
   intro:       '#94a3b8',
 } as const;
 
-const CATEGORY_ORDER: PanelCategory[] = ['development', 'agent', 'monitoring', 'session', 'ai'];
+const CATEGORY_ORDER: PanelCategory[] = ['agent', 'monitoring', 'session', 'ai'];
 const CATEGORY_LABELS: Record<PanelCategory, string> = {
-  development: 'Development',
   agent:       'Agent',
   monitoring:  'Monitoring',
   session:     'Session',

package/src/panels/panel-picker.ts

@@ -1,11 +1,10 @@
 import type { PanelRegistration, PanelCategory } from './types.ts';
 
 /** Display order for panel categories. */
-const CATEGORY_ORDER: PanelCategory[] = ['development', 'agent', 'monitoring', 'session', 'ai'];
+const CATEGORY_ORDER: PanelCategory[] = ['agent', 'monitoring', 'session', 'ai'];
 
 /** Human-readable labels for each category. */
 const CATEGORY_LABELS: Record<PanelCategory, string> = {
-  development: 'Development',
   agent:       'Agent',
   monitoring:  'Monitoring',
   session:     'Session',

package/src/panels/types.ts

@@ -1,7 +1,7 @@
 import type { Line } from '../types/grid.ts';
 import type { ComponentResourceContract, ComponentHealthState } from '../runtime/perf/panel-contracts.ts';
 
-export type PanelCategory = 'development' | 'agent' | 'monitoring' | 'session' | 'ai';
+export type PanelCategory = 'agent' | 'monitoring' | 'session' | 'ai';
 
 export interface Panel {
   id: string;

package/src/renderer/help-overlay.ts

@@ -70,7 +70,7 @@ export function renderHelpOverlay(
   // Commands not registered in the live registry are omitted at render time.
   const FEATURED_COMMANDS: Array<[name: string, argHint: string, desc: string]> = [
     ['agent',        '',           'Open the Agent operator workspace'],
-    ['onboarding',   '',           'Open Agent setup with current settings preloaded'],
+    ['setup',        '',           'Open Agent setup with current settings preloaded'],
     ['knowledge',    'status',     'Inspect isolated Agent Knowledge readiness'],
     ['memory',       '',           'Manage local Agent memory records'],
     ['personas',     '',           'Manage serial Agent operating personas'],
@@ -119,7 +119,7 @@ export function renderHelpOverlay(
     commandRows.push('', '  Available Slash Commands', '  ' + '\u2500'.repeat(40));
     const preferred = [
       'agent',
-      'onboarding',
+      'setup',
       'knowledge',
       'memory',
       'personas',
@@ -238,7 +238,7 @@ export function renderShortcutsOverlay(
     row(kb('clear-prompt'), 'Clear prompt'),
     row(kb('delete-word'), 'Delete word backward'),
     row(kb('kill-line'), 'Kill to end of line'),
-    row(kb('apply-diff-line-start'), 'Diff apply blocked / line start'),
+    row(kb('apply-diff-line-start'), 'Delegate diff changes / line start'),
     row(kb('next-error-line-end'), 'Next error / line end'),
     '',
     '  Actions',
@@ -246,7 +246,7 @@ export function renderShortcutsOverlay(
     row('Tab', 'Collapse/expand block'),
     row(kb('bookmark'), 'Bookmark block'),
     row(kb('block-copy'), 'Copy block to clipboard'),
-    row(kb('block-save'), 'Block save blocked; use /share --yes'),
+    row(kb('block-save'), 'Block file save disabled; copy or export'),
     row(kb('copy-selection'), 'Copy selection'),
     row('F2', 'Process monitor'),
     row('?', 'Help overlay'),

package/src/renderer/settings-modal.ts

@@ -31,7 +31,7 @@ const CATEGORY_INFO: Record<SettingsCategory, string> = {
   storage: 'Local storage posture, including secret storage policy and maximum artifact size for Agent Knowledge, artifacts, and document ingestion.',
   permissions: 'Permission mode and tool-class policy. These settings decide whether the shell prompts before read/write/exec/network/agent actions.',
   orchestration: 'Agent orchestration limits and recursion controls.',
-  wrfc: 'WRFC is external to normal Agent operation. Review these copied compatibility values only for explicit GoodVibes TUI build delegation.',
+  wrfc: 'WRFC is external to normal Agent operation. Review these runtime compatibility values only for explicit GoodVibes TUI build delegation.',
   helper: 'Helper model defaults used by helper subsystems when they do not use the main chat route.',
   tts: 'Text-to-speech provider, voice, and optional spoken-turn LLM overrides.',
   service: 'External runtime installation posture. Agent shows these compatibility keys for inspection only and does not install, start, stop, restart, or autostart anything.',

package/src/runtime/bootstrap.ts

@@ -553,8 +553,8 @@ export async function bootstrapRuntime(
   };
 
   // ── Phase 12b: Operator intervention wiring (feature-gated) ──────────────
-  // Keep the copied control-plane state internal. GoodVibes Agent does not
-  // expose the copied local ops-control panel; operator control is surfaced
+  // Keep runtime-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;
 

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

@@ -1,16 +1,16 @@
 import type { Tool } from '@pellux/goodvibes-sdk/platform/types';
 
 const CONTEXT_TOOL_DENIAL = [
-  'GoodVibes Agent does not expose copied GoodVibes runtime context through model tools in the main conversation.',
-  'The copied context tool can describe TUI/default runtime assumptions that are not the Agent product boundary.',
+  'GoodVibes Agent does not expose non-Agent runtime context through model tools in the main conversation.',
+  'The runtime context tool can describe assumptions that are outside the Agent product boundary.',
   'Use explicit Agent CLI/slash commands such as status, compat, setup, and isolated Agent Knowledge instead.',
 ].join(' ');
 
 export function wrapBlockedContextToolForAgentPolicy(tool: Tool): void {
   tool.definition.description = [
-    'Blocked in GoodVibes Agent main conversation: copied runtime context.',
+    '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 copied TUI runtime assumptions are not Agent fallbacks.',
+    'Default Knowledge/Wiki, non-Agent knowledge segments, and non-Agent runtime assumptions are not Agent fallbacks.',
   ].join(' ');
   tool.definition.sideEffects = [];
   tool.definition.parameters = {