@pellux/goodvibes-agent 0.1.107 → 0.1.109

package/src/input/commands/session-content.ts

@@ -144,7 +144,7 @@ export function registerSessionContentCommands(registry: CommandRegistry): void
         if (meta.title) ctx.session.conversationManager.title = meta.title;
         ctx.session.conversationManager.rebuildHistory();
         ctx.renderRequest();
-        ctx.print(`Session loaded: ${args[0]} (${messages.length} messages)${agentRecords.length > 0 ? ` [ignored ${agentRecords.length} runtime-owned local agent record${agentRecords.length !== 1 ? 's' : ''}]` : ''}`);
+        ctx.print(`Session loaded: ${args[0]} (${messages.length} messages)${agentRecords.length > 0 ? ` [ignored ${agentRecords.length} service-owned local agent record${agentRecords.length !== 1 ? 's' : ''}]` : ''}`);
       } catch (e) {
         ctx.print(`Failed to load session: ${summarizeError(e)}`);
       }

package/src/input/commands/session-workflow.ts

@@ -264,7 +264,7 @@ export async function handleSessionWorkflowCommand(args: string[], ctx: CommandC
           ctx.print(`  Reopened panels: ${reopenedPanels.join(', ')}`);
         }
         if ((meta.returnContext.remoteRunners?.length ?? 0) > 0) {
-          ctx.print('  Remote re-entry: use the external runtime host for remote runner recovery; delegate explicit build/fix/review recovery from Agent.');
+          ctx.print('  Remote re-entry: handle remote runner recovery outside Agent; delegate explicit build/fix/review recovery from Agent.');
         }
         if ((meta.returnContext.worktreePaths?.length ?? 0) > 0) {
           ctx.print('  Worktree re-entry: open GoodVibes TUI in the target workspace; delegate explicit build/fix/review recovery from Agent.');

package/src/input/commands/shell-core.ts

@@ -116,13 +116,15 @@ export function registerShellCoreCommands(registry: CommandRegistry): void {
         const items: SelectionItem[] = [
           { id: '/agent', label: '/agent', detail: 'Open the Agent operator workspace', category: 'Agent Operator' },
           { id: '/home', label: '/home', detail: 'Alias for the Agent operator workspace', category: 'Agent Operator' },
+          { id: '/brief', label: '/brief', detail: 'Show a concise Agent operator briefing and next actions', category: 'Agent Operator' },
           { id: '/knowledge', label: '/knowledge', detail: 'Inspect isolated Agent Knowledge status, ask/search, and ingest flows', category: 'Agent Operator' },
           { id: '/memory', label: '/memory', detail: 'Review local Agent memory records', category: 'Agent Operator' },
           { id: '/personas', label: '/personas', detail: 'Create, review, and activate local Agent personas', category: 'Agent Operator' },
           { id: '/agent-skills', label: '/agent-skills', detail: 'Create, review, and enable reusable Agent skills', category: 'Agent Operator' },
           { id: '/routines', label: '/routines', detail: 'Create, review, start, and promote Agent routines explicitly', category: 'Agent Operator' },
           { id: '/delegate', label: '/delegate [task]', detail: 'Explicit build/fix/review handoff to GoodVibes TUI', category: 'Agent Operator' },
-          { id: '/pair', label: '/pair', detail: 'Pair companion clients through the GoodVibes runtime', category: 'Agent Operator' },
+          { id: '/channels', label: '/channels', detail: 'Inspect messaging-channel readiness without sending messages', category: 'Agent Operator' },
+          { id: '/pair', label: '/pair', detail: 'Pair companion clients through connected GoodVibes services', category: 'Agent Operator' },
           { id: '/model', label: '/model [id]', detail: 'Select LLM model', category: 'Model & Provider' },
           { id: '/provider', label: '/provider [name]', detail: 'Switch provider', category: 'Model & Provider' },
           { id: '/effort', label: '/effort [level]', detail: 'Reasoning effort (instant/low/medium/high)', category: 'Model & Provider' },
@@ -170,7 +172,7 @@ export function registerShellCoreCommands(registry: CommandRegistry): void {
         });
         return;
       }
-      ctx.print('Use /help to open the help modal. Commands: /agent, /knowledge, /memory, /personas, /agent-skills, /routines, /delegate, /model, /provider, /config, /paste, /sessions, /bookmarks, /save, /load, /undo, /redo, /retry, /clear, /reset, /compact, /export, /title, /effort, /expand, /collapse, /quit');
+      ctx.print('Use /help to open the help modal. Commands: /agent, /brief, /knowledge, /memory, /personas, /agent-skills, /routines, /channels, /delegate, /model, /provider, /config, /paste, /sessions, /bookmarks, /save, /load, /undo, /redo, /retry, /clear, /reset, /compact, /export, /title, /effort, /expand, /collapse, /quit');
     },
   });
 

package/src/input/commands/tasks-runtime.ts

@@ -16,10 +16,10 @@ const BLOCKED_TASK_MUTATIONS: ReadonlySet<string> = new Set([
 function printTaskMutationBlocked(print: (text: string) => void, subcommand: string): void {
   print([
     `Task mutation "${subcommand}" is blocked in GoodVibes Agent.`,
-    '  policy: runtime tasks are read-only from the Agent TUI; normal work stays in the main conversation.',
+    '  policy: connected-service tasks are read-only from the Agent TUI; normal work stays in the main conversation.',
     '  durable tasks: use /workplan for visible planning and task tracking.',
     '  build/fix/review: use /delegate <task> to hand explicit implementation work to GoodVibes TUI.',
-    '  result: no local runtime task state was changed.',
+    '  result: no local task state was changed.',
   ].join('\n'));
 }
 
@@ -51,7 +51,7 @@ export function registerTasksRuntimeCommands(registry: CommandRegistry): void {
   registry.register({
     name: 'tasks',
     aliases: ['task'],
-    description: 'Inspect runtime tasks without starting or mutating local background work',
+    description: 'Inspect connected-service tasks without starting or mutating local background work',
     usage: '[list [status|kind] | show <taskId> | output <taskId>]',
     handler(args, ctx) {
       if (args.length === 0) {

package/src/input/commands.ts

@@ -35,6 +35,8 @@ import { registerDelegationRuntimeCommands } from './commands/delegation-runtime
 import { registerPersonasRuntimeCommands } from './commands/personas-runtime.ts';
 import { registerAgentSkillsRuntimeCommands } from './commands/agent-skills-runtime.ts';
 import { registerRoutinesRuntimeCommands } from './commands/routines-runtime.ts';
+import { registerChannelsRuntimeCommands } from './commands/channels-runtime.ts';
+import { registerBriefRuntimeCommands } from './commands/brief-runtime.ts';
 
 function registerAgentMemoryCommand(registry: CommandRegistry): void {
   registry.register({
@@ -56,10 +58,12 @@ function registerAgentMemoryCommand(registry: CommandRegistry): void {
 export function registerBuiltinCommands(registry: CommandRegistry): void {
   registerShellCoreCommands(registry);
   registerAgentWorkspaceRuntimeCommands(registry);
+  registerBriefRuntimeCommands(registry);
   registerAgentRuntimeProfileRuntimeCommands(registry);
   registerPersonasRuntimeCommands(registry);
   registerAgentSkillsRuntimeCommands(registry);
   registerRoutinesRuntimeCommands(registry);
+  registerChannelsRuntimeCommands(registry);
   registerDelegationRuntimeCommands(registry);
   registerConfigCommand(registry);
   registerOperatorRuntimeCommands(registry);

package/src/input/handler-onboarding.ts

@@ -487,11 +487,11 @@ export function getOnboardingRuntimePostureForHandler(handler: InputHandler, req
 export async function restartOnboardingExternalServicesIfNeededForHandler(handler: InputHandler, request: OnboardingApplyRequest): Promise<OnboardingVerificationItem[]> {
     const externalServices = handler.uiServices.platform.externalServices;
     const state = externalServices?.inspect();
-    const serviceStatus = state?.daemonStatus?.reason ?? (state?.daemonRunning ? 'external GoodVibes runtime appears active' : 'external GoodVibes runtime is not verified from this shell');
+    const serviceStatus = state?.daemonStatus?.reason ?? (state?.daemonRunning ? 'connected GoodVibes services appear active' : 'connected GoodVibes services are not verified from this shell');
     return [{
       id: 'runtime:external-service-owned',
       status: 'pass',
-      message: `GoodVibes Agent did not start, stop, restart, or reconfigure runtime lifecycle. ${serviceStatus}`,
+      message: `GoodVibes Agent did not start, stop, restart, or reconfigure connected services. ${serviceStatus}`,
       target: 'service',
     }];
   }
@@ -503,8 +503,8 @@ export function verifyOnboardingRuntimePostureForHandler(handler: InputHandler,
       id: 'runtime:external-service-owned',
       status: 'pass',
       message: externalState
-        ? 'GoodVibes runtime lifecycle is externally managed; Agent onboarding did not request shutdown, startup, restart, bind, or surface changes.'
-        : 'GoodVibes runtime lifecycle is externally managed; no local service controller is required for Agent onboarding.',
+        ? 'Connected GoodVibes services are managed outside Agent; Agent onboarding did not request shutdown, startup, restart, bind, or surface changes.'
+        : 'Connected GoodVibes services are managed outside Agent; no local service controller is required for Agent onboarding.',
       target: 'service',
     }];
   }

package/src/input/handler.ts

@@ -26,6 +26,7 @@ import { BookmarkModal } from './bookmark-modal.ts';
 import { SettingsModal } from './settings-modal.ts';
 import { McpWorkspace } from './mcp-workspace.ts';
 import { AgentWorkspace } from './agent-workspace.ts';
+import { parseSlashCommand } from './slash-command-parser.ts';
 import { SessionPickerModal } from './session-picker-modal.ts';
 import { ProfilePickerModal } from './profile-picker-modal.ts';
 import { OnboardingWizardController, type OnboardingWizardAction, type OnboardingWizardMode } from './onboarding/onboarding-wizard.ts';
@@ -423,9 +424,9 @@ export class InputHandler {
     for (let index = this.modalStack.length - 1; index >= 0; index -= 1) {
       if (this.modalStack[index] === 'agentWorkspace') this.modalStack.splice(index, 1);
     }
-    const [name, ...args] = command.trim().replace(/^\//, '').split(/\s+/);
+    const { name, args } = parseSlashCommand(command);
     if (!name) return;
-    void context.executeCommand?.(name, args).catch((error: unknown) => {
+    void context.executeCommand?.(name, [...args]).catch((error: unknown) => {
       context.print(`Agent workspace command failed: ${error instanceof Error ? error.message : String(error)}`);
       this.requestRender();
     });

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

@@ -49,7 +49,7 @@ export function buildDefaultDerivedState(): OnboardingStepDerivationState {
         required: false,
         accepted: false,
         reason: 'not-needed',
-        detail: 'No external runtime auth signal needs confirmation.',
+        detail: 'No connected-service auth signal needs confirmation.',
       },
     },
   };

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

@@ -5,10 +5,10 @@ export function buildCommunicationStep(): OnboardingWizardStepDefinition {
     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.',
+    description: 'Prepare companion pairing, messaging-channel readiness, notification delivery, and safe outbound communication for day-one Agent use.',
     summaryTitle: 'Communication posture',
     summaryLines: [
-      'Companion chat: paired through the GoodVibes runtime',
+      'Companion chat: paired through connected GoodVibes services',
       'Channel accounts: inspect readiness before using them',
       'Outbound messages: explicit user action only',
     ],
@@ -17,14 +17,14 @@ export function buildCommunicationStep(): OnboardingWizardStepDefinition {
         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',
+        hint: 'Use /pair from the Agent workspace to pair companion clients through connected GoodVibes services.',
+        defaultValue: 'Pair when ready',
       },
       {
         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.',
+        hint: 'Use the Channels workspace to inspect account readiness, delivery posture, and recent communication without changing connection state.',
         defaultValue: 'Inspectable',
       },
       {
@@ -38,7 +38,7 @@ export function buildCommunicationStep(): OnboardingWizardStepDefinition {
         kind: 'status',
         id: 'agent-communication.inbound-policy',
         label: 'Inbound command policy',
-        hint: 'Incoming channel commands stay constrained by runtime policy, allowlists, and account posture.',
+        hint: 'Incoming channel commands stay constrained by Agent policy, allowlists, and account posture.',
         defaultValue: 'Policy gated',
       },
     ],
@@ -50,7 +50,7 @@ export function buildToolsStep(): OnboardingWizardStepDefinition {
     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.',
+    description: 'Review tool access for the Agent operator: MCP connections, browser/media helpers, safe read-only inspection, and explicit approval before side effects.',
     summaryTitle: 'Tool posture',
     summaryLines: [
       'MCP and tools: inspect before use',
@@ -61,8 +61,8 @@ export function buildToolsStep(): OnboardingWizardStepDefinition {
       {
         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.',
+        label: 'MCP connections and tools',
+        hint: 'Use /mcp servers and the Agent workspace Tools area to inspect connected MCP servers, roles, and tool readiness.',
         defaultValue: 'Inspectable',
       },
       {
@@ -178,11 +178,11 @@ export function buildAutomationStep(): OnboardingWizardStepDefinition {
     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.',
+    description: 'Set the Agent automation posture: local routines run in the main conversation, while connected schedules remain explicit.',
     summaryTitle: 'Routine and schedule posture',
     summaryLines: [
       'Local routines: reusable main-conversation workflows',
-      'External schedules: explicit promotion only',
+      'Connected schedules: explicit promotion only',
       'Runs/cancels/retries: command-confirmed side effects',
     ],
     fields: [
@@ -204,7 +204,7 @@ export function buildAutomationStep(): OnboardingWizardStepDefinition {
         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.',
+        hint: 'Creating connected schedules from routines requires a reviewed routine, a real timing expression, optional delivery target, and explicit confirmation.',
         defaultValue: 'Explicit command',
       },
       {
@@ -223,7 +223,7 @@ export function buildVoiceMediaStep(): OnboardingWizardStepDefinition {
     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.',
+    description: 'Prepare voice, speech, image input, and media understanding as optional Agent operator tools.',
     summaryTitle: 'Voice and media posture',
     summaryLines: [
       'Voice and speech: optional operator tools',

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

@@ -114,10 +114,10 @@ function buildReviewReadinessFields(controller: OnboardingWizardController): rea
     {
       kind: 'status',
       id: 'review.readiness.connection',
-      label: 'Runtime connection snapshot',
+      label: 'Connected services snapshot',
       hint: collectionIssues > 0
         ? `${collectionIssues} setup snapshot issue(s) need attention before this Agent is day-one ready.`
-        : 'The setup snapshot loaded cleanly from the external GoodVibes runtime.',
+        : 'The setup snapshot loaded cleanly from connected GoodVibes services.',
       defaultValue: collectionIssues > 0 ? 'Needs attention' : 'Ready',
       spacerBeforeRows: 1,
     },
@@ -160,7 +160,7 @@ function buildReviewReadinessFields(controller: OnboardingWizardController): rea
       kind: 'status',
       id: 'review.readiness.automation',
       label: 'Routines and schedules',
-      hint: automation?.detail ?? 'Local routines run in the main conversation; external schedules require explicit promotion and confirmation.',
+      hint: automation?.detail ?? 'Local routines run in the main conversation; connected schedules require explicit promotion and confirmation.',
       defaultValue: automation?.selected ? 'Review configured' : 'Local first',
     },
     {
@@ -211,7 +211,7 @@ export function buildAgentSetupStep(controller: OnboardingWizardController): Onb
     summaryLines: [
       'Agent owns the operator TUI and local behavior registry.',
       'Optional starter profile: create an isolated Agent home from setup.',
-      'GoodVibes runtime lifecycle is external to this product.',
+      'Setup here changes only Agent-owned settings and local state.',
       `Secret policy: ${controller.getStringFieldValue('agent-setup.secret-policy', secretPolicy)}`,
       collectionIssues > 0 ? `${collectionIssues} setup snapshot issue(s)` : 'Setup snapshot collected cleanly',
     ],
@@ -226,11 +226,11 @@ export function buildAgentSetupStep(controller: OnboardingWizardController): Onb
       {
         kind: 'status',
         id: 'agent-setup.connection',
-        label: 'GoodVibes runtime connection',
+        label: 'Connected GoodVibes services',
         hint: collectionIssues > 0
           ? `${collectionIssues} setup snapshot issue(s) were reported. Status and doctor commands show connection details.`
-          : 'Agent connects to an already-running GoodVibes runtime for companion chat, work plans, approvals, automation, and Agent Knowledge.',
-        defaultValue: collectionIssues > 0 ? `${collectionIssues} issue(s)` : 'External',
+          : 'Agent uses connected GoodVibes services for companion chat, work plans, approvals, automation, and Agent Knowledge.',
+        defaultValue: collectionIssues > 0 ? `${collectionIssues} issue(s)` : 'Connected',
       },
       {
         kind: 'radio',
@@ -514,7 +514,7 @@ export function buildReviewStep(controller: OnboardingWizardController): Onboard
         id: 'review.apply',
         action: 'apply',
         label: 'Apply Agent settings and verify',
-        hint: 'Persist the Agent-owned settings and verify that no runtime lifecycle, non-Agent entrypoint, default wiki, or non-Agent knowledge setup was requested.',
+        hint: 'Persist Agent-owned settings and verify that setup did not request non-Agent entrypoints, default wiki access, or non-Agent knowledge setup.',
         defaultValue: 'Ready',
       },
     ],

package/src/input/settings-modal-agent-policy.ts

@@ -1,4 +1,4 @@
-export const AGENT_EXTERNAL_DAEMON_SETTING_LOCK_REASON = 'GoodVibes Agent connects to an external GoodVibes runtime. Change runtime lifecycle and bind posture from the owning host; Agent settings are read-only for those controls.';
+export const AGENT_EXTERNAL_DAEMON_SETTING_LOCK_REASON = 'GoodVibes Agent uses connected GoodVibes services. Change service lifecycle and bind posture from the owning host; Agent settings are read-only for those controls.';
 
 const AGENT_HIDDEN_SETTING_PREFIXES = [
   ['cloud', 'flare.'].join(''),

package/src/input/slash-command-parser.ts

@@ -0,0 +1,60 @@
+export interface ParsedSlashCommand {
+  readonly name: string;
+  readonly args: readonly string[];
+}
+
+export function parseSlashCommand(command: string): ParsedSlashCommand {
+  const tokens = tokenizeSlashCommand(command.trim().replace(/^\//, ''));
+  return {
+    name: tokens[0] ?? '',
+    args: tokens.slice(1),
+  };
+}
+
+export function tokenizeSlashCommand(command: string): readonly string[] {
+  const tokens: string[] = [];
+  let current = '';
+  let quote: '"' | "'" | null = null;
+  let escaping = false;
+
+  for (const char of command) {
+    if (escaping) {
+      current += char;
+      escaping = false;
+      continue;
+    }
+    if (char === '\\') {
+      escaping = true;
+      continue;
+    }
+    if (quote) {
+      if (char === quote) {
+        quote = null;
+        continue;
+      }
+      current += char;
+      continue;
+    }
+    if (char === '"' || char === "'") {
+      quote = char;
+      continue;
+    }
+    if (/\s/.test(char)) {
+      if (current.length > 0) {
+        tokens.push(current);
+        current = '';
+      }
+      continue;
+    }
+    current += char;
+  }
+
+  if (escaping) current += '\\';
+  if (current.length > 0) tokens.push(current);
+  return tokens;
+}
+
+export function quoteSlashCommandArg(value: string): string {
+  if (/^[A-Za-z0-9._/:=@,+-]+$/.test(value)) return value;
+  return `"${value.replace(/\\/g, '\\\\').replace(/"/g, '\\"')}"`;
+}

package/src/panels/builtin/agent.ts

@@ -80,7 +80,7 @@ export function registerAgentPanels(manager: PanelManager, deps: ResolvedBuiltin
     name: 'Schedule',
     icon: 'Z',
     category: 'agent',
-    description: 'Read-only schedule posture from the external runtime; local Agent schedule mutation is blocked',
+    description: 'Read-only schedule posture from connected GoodVibes services; local Agent schedule mutation is blocked',
     factory: () => new SchedulePanel(requireAutomationManager(deps)),
   });
 }

package/src/panels/builtin/operations.ts

@@ -45,7 +45,7 @@ export function registerOperationsPanels(manager: PanelManager, deps: ResolvedBu
     name: 'Automation',
     icon: 'M',
     category: 'monitoring',
-    description: 'Read-only automation jobs, runs, deliveries, and failure posture from the external runtime',
+    description: 'Read-only automation jobs, runs, deliveries, and failure posture from connected GoodVibes services',
     factory: () => new AutomationControlPanel(ui.readModels.automation),
   });
 
@@ -81,7 +81,7 @@ export function registerOperationsPanels(manager: PanelManager, deps: ResolvedBu
     name: 'Tasks',
     icon: 'J',
     category: 'monitoring',
-    description: 'Queued, running, blocked, failed, and completed task summaries from the external runtime',
+    description: 'Queued, running, blocked, failed, and completed task summaries from connected GoodVibes services',
     factory: () => new TasksPanel(ui.readModels.tasks),
   });
 

package/src/panels/provider-account-snapshot.ts

@@ -217,7 +217,7 @@ export async function buildProviderAccountSnapshot(
     }
     if (hasServiceOAuth && !serviceOauth?.usable) {
       issues.push('Service OAuth is configured but missing a usable credential.');
-      recommendedActions.push(`Repair service OAuth credentials for ${providerId} in /settings or the external runtime host.`);
+      recommendedActions.push(`Repair service OAuth credentials for ${providerId} in /settings or the owning GoodVibes host.`);
     }
 
     return {

package/src/panels/provider-health-domains.ts

@@ -46,13 +46,13 @@ export function buildProviderHealthDomainSummaries(
     name: 'auth',
     level: auth.bootstrapCredentialPresent ? 'warn' : 'info',
     summary: auth.bootstrapCredentialPresent
-      ? 'external runtime bootstrap credential visible in local compatibility state'
-      : 'runtime auth administration belongs to the external runtime owner',
+      ? 'connected-service bootstrap credential visible in local compatibility state'
+      : 'connected-service auth administration belongs outside Agent',
     next: '/auth review',
     details: [
-      'GoodVibes Agent does not create, delete, rotate, revoke, or clear runtime auth users or sessions.',
+      'GoodVibes Agent does not create, delete, rotate, revoke, or clear connected-service auth users or sessions.',
       `${auth.userCount} compatibility user record(s) and ${auth.sessionCount} session record(s) are visible for diagnostics only.`,
-      auth.bootstrapCredentialPresent ? 'Runtime bootstrap cleanup must be done from the runtime-owning TUI or host tooling.' : '',
+      auth.bootstrapCredentialPresent ? 'Bootstrap cleanup must be done in the owning GoodVibes host.' : '',
     ].filter(Boolean),
     nextSteps: auth.bootstrapCredentialPresent
       ? ['/auth review', '/provider', '/subscription providers']
@@ -64,10 +64,10 @@ export function buildProviderHealthDomainSummaries(
     name: 'settings',
     level: !settings.available ? 'info' : settingIssueCount > 0 ? 'warn' : 'good',
     summary: !settings.available
-      ? 'settings runtime API unavailable'
+      ? 'settings API unavailable'
       : settingIssueCount > 0
         ? `${settings.conflictCount} conflicts / ${settings.recentFailureCount} failures${settings.hasStagedManagedBundle ? ' / staged bundle' : ''}`
-        : 'settings runtime API clean',
+        : 'settings API clean',
     next: settingIssueCount > 0 ? '/settings' : '/config <key>',
     details: [
       settings.conflictCount > 0 ? `${settings.conflictCount} unresolved import conflict(s)` : '',

package/src/panels/subscription-panel.ts

@@ -80,7 +80,7 @@ export class SubscriptionPanel extends ScrollableListPanel<SubscriptionRow> {
     return [
       { command: '/subscription login openai start --yes', summary: 'start the first-class OpenAI subscription flow' },
       { command: '/login provider <name> start --yes', summary: 'use the front-door auth flow for supported providers' },
-      { command: '/auth review', summary: 'inspect runtime auth posture without exposing token values' },
+      { command: '/auth review', summary: 'inspect connected-service auth posture without exposing token values' },
     ];
   }
 

package/src/panels/tasks-panel.ts

@@ -183,9 +183,9 @@ export class TasksPanel extends ScrollableListPanel<RuntimeTask> {
         sections: [{
           lines: buildEmptyState(
             width,
-            ' Runtime store not wired into this panel yet.',
-            'Use the Tasks panel with a live runtime store to review active execution, cancellations, retries, and completion results.',
-            [{ command: '/tasks', summary: 'inspect runtime tasks without starting background work' }],
+            ' Task store not wired into this panel yet.',
+            'Use the Tasks panel with live connected-service task state to review active execution, cancellations, retries, and completion results.',
+            [{ command: '/tasks', summary: 'inspect connected-service tasks without starting background work' }],
             C,
           ),
         }],

package/src/renderer/agent-workspace.ts

@@ -196,8 +196,8 @@ function snapshotLines(workspace: AgentWorkspace, category: AgentWorkspaceCatego
     );
   } else if (category.id === 'setup') {
     base.push(
-      { text: `GoodVibes runtime: ${snapshot.runtimeBaseUrl}`, fg: PALETTE.info },
-      { text: `Runtime owner: ${snapshot.runtimeOwnership}; Agent connects but never starts or restarts it`, fg: PALETTE.good },
+      { text: `Connection: ${snapshot.runtimeBaseUrl}`, fg: PALETTE.info },
+      { text: 'Agent role: interactive operator TUI; setup changes here are Agent-local.', fg: PALETTE.good },
       ...setupChecklistLines(snapshot),
       { text: '' },
       { text: `Workspace: ${snapshot.workingDirectory}`, fg: PALETTE.muted },
@@ -218,13 +218,13 @@ function snapshotLines(workspace: AgentWorkspace, category: AgentWorkspaceCatego
       ...snapshot.channels.filter((channel) => !channel.enabled),
     ].slice(0, 6);
     base.push(
-      { text: `GoodVibes runtime: ${snapshot.runtimeBaseUrl}`, fg: PALETTE.info },
+      { text: `GoodVibes API: ${snapshot.runtimeBaseUrl}`, fg: PALETTE.info },
       { text: `Readiness: ${readyCount}/${snapshot.channels.length} ready; ${enabledCount} enabled; ${configuredDefaults} default target(s) configured.`, fg: PALETTE.info },
       { text: `Ready channels: ${readyChannels.join(', ') || 'none'}.`, fg: readyChannels.length > 0 ? PALETTE.good : PALETTE.warn },
       { text: `Needs default target: ${needsTarget.map((channel) => `${channel.label} -> ${channel.defaultTargetKeys.join('|')}`).join(', ') || 'none'}.`, fg: needsTarget.length > 0 ? PALETTE.warn : PALETTE.muted },
       { text: `Needs config: ${needsConfig.map((channel) => `${channel.label} -> ${channel.missingRequiredKeys.join('|')}`).join(', ') || 'none'}.`, fg: needsConfig.length > 0 ? PALETTE.warn : PALETTE.muted },
       { text: `Disabled channels: ${disabledPreview || 'none'}${disabledSuffix}.`, fg: PALETTE.dim },
-      { text: 'Safety: no secret values; sends and public exposure require explicit user action and runtime policy.', fg: PALETTE.warn },
+      { text: 'Safety: no secret values; sends and public exposure require explicit user action and Agent policy.', fg: PALETTE.warn },
     );
     for (const channel of orderedChannels) {
       const ready = channel.ready ? 'ready' : `${channel.missingConfigCount} missing`;
@@ -297,13 +297,13 @@ function snapshotLines(workspace: AgentWorkspace, category: AgentWorkspaceCatego
       { text: '' },
       { text: 'Named Agent profiles isolate local config, sessions, memory, personas, skills, routines, setup, and bundles.', fg: PALETTE.good },
       { text: 'Starter authoring: browse, export, edit, import, and create Agent profiles from inside this workspace.', fg: PALETTE.info },
-      { text: 'The external GoodVibes runtime remains shared unless the owning host is configured separately.', fg: PALETTE.warn },
+      { text: 'Connected GoodVibes services stay shared unless the owning host is configured separately.', fg: PALETTE.warn },
       { text: 'Portable bundles require explicit export/import commands with real paths and --yes.', fg: PALETTE.muted },
     );
   } else if (category.id === 'memory') {
     base.push(
       { text: `Session memories: ${snapshot.sessionMemoryCount}`, fg: PALETTE.info },
-      { text: `Agent memory: ${snapshot.localMemoryCount}; review queue: ${snapshot.localMemoryReviewQueueCount}`, fg: PALETTE.info },
+      { text: `Agent memory: ${snapshot.localMemoryCount}; prompt-active: ${snapshot.localMemoryPromptActiveCount}; review queue: ${snapshot.localMemoryReviewQueueCount}`, fg: PALETTE.info },
       { text: `Local routines: ${snapshot.localRoutineCount}; enabled: ${snapshot.enabledRoutineCount}`, fg: PALETTE.info },
       { text: `Local skills: ${snapshot.localSkillCount}; enabled: ${snapshot.enabledSkillCount}; bundles: ${snapshot.localSkillBundleCount}; active skills: ${snapshot.activeSkillCount}`, fg: PALETTE.info },
       { text: `Local personas: ${snapshot.localPersonaCount}; active: ${snapshot.activePersonaName}`, fg: PALETTE.info },
@@ -334,7 +334,7 @@ function snapshotLines(workspace: AgentWorkspace, category: AgentWorkspaceCatego
     base.push(
       { text: `Routines: ${snapshot.localRoutineCount}; enabled: ${snapshot.enabledRoutineCount}`, fg: PALETTE.info },
       { text: 'Routines are repeatable main-conversation workflows. Starting one does not create hidden jobs.', fg: PALETTE.good },
-      { text: 'Scheduling a reviewed routine is explicit and writes to the external GoodVibes runtime only with --yes.', fg: PALETTE.warn },
+      { text: 'Scheduling a reviewed routine is explicit and requires a confirmed schedule command.', fg: PALETTE.warn },
       { text: '' },
       ...localLibraryLines('Routine Library', snapshot.localRoutines, 'No local routines yet. Create one here with Create routine.', workspace.selectedLocalLibraryItem('routine')?.id ?? null),
     );
@@ -346,7 +346,8 @@ function snapshotLines(workspace: AgentWorkspace, category: AgentWorkspaceCatego
   } else if (category.id === 'automation') {
     base.push(
       { text: 'Automation and schedules default to read-only observability.', fg: PALETTE.info },
-      { text: 'Run/pause/resume/cancel/retry require exact explicit commands and confirmation.', fg: PALETTE.warn },
+      { text: 'Confirmed reminders and routine promotion use connected schedules only.', fg: PALETTE.info },
+      { text: 'Local scheduler mutation/run controls remain blocked.', fg: PALETTE.warn },
     );
   } else if (category.id === 'delegate') {
     base.push(
@@ -430,34 +431,46 @@ function buildEditorRows(editor: AgentWorkspaceLocalEditor, width: number, heigh
     { text: editor.message, fg: PALETTE.info },
     { text: '' },
   ];
-  for (let index = 0; index < editor.fields.length; index += 1) {
-    const field = editor.fields[index]!;
-    const selected = index === editor.selectedFieldIndex;
-    const marker = selected ? GLYPHS.navigation.selected : ' ';
-    const required = field.required ? ' *' : '';
-    const value = field.value.length > 0 ? field.value : '(empty)';
-    const color = selected ? PALETTE.text : field.value.length > 0 ? PALETTE.info : PALETTE.muted;
-    rows.push({
-      text: `${marker} ${field.label}${required}`,
-      selected,
-      fg: color,
-      bold: selected,
-    });
-    const valueLines = value.split('\n');
-    for (const valueLine of valueLines.slice(0, 4)) {
-      for (const wrapped of wrapText(`  ${valueLine}`, Math.max(1, width - 2))) {
-        rows.push({ text: wrapped, fg: field.value.length > 0 ? PALETTE.text : PALETTE.dim, dim: field.value.length === 0 });
-      }
-    }
-    if (valueLines.length > 4) rows.push({ text: `  ${valueLines.length - 4} more line(s)`, fg: PALETTE.dim, dim: true });
-    rows.push({ text: `  ${field.hint}`, fg: PALETTE.dim, dim: true });
+  const footerRows: WorkspaceRow[] = [
+    { text: '' },
+    { text: 'Enter next/save · Up/Down field · Backspace edit · Ctrl-J newline · Esc cancel', fg: PALETTE.muted },
+  ];
+  const visibleFields = Math.max(1, Math.floor(Math.max(1, height - rows.length - footerRows.length) / 3));
+  const window = stableWindow(editor.fields.length, editor.selectedFieldIndex, visibleFields);
+  if (window.start > 0) rows.push({ text: `${GLYPHS.navigation.moreAbove} ${window.start} more field(s) above`, kind: 'more', fg: PALETTE.dim, dim: true });
+  for (let index = window.start; index < window.end; index += 1) {
+    rows.push(...buildEditorFieldRows(editor, index, width));
   }
-  rows.push({ text: '' });
-  rows.push({ text: 'Enter next/save · Up/Down field · Backspace edit · Ctrl-J newline · Esc cancel', fg: PALETTE.muted });
+  if (window.end < editor.fields.length) rows.push({ text: `${GLYPHS.navigation.moreBelow} ${editor.fields.length - window.end} more field(s) below`, kind: 'more', fg: PALETTE.dim, dim: true });
+  rows.push(...footerRows);
   while (rows.length < height) rows.push({ text: '', kind: 'empty' });
   return rows.slice(0, height);
 }
 
+function buildEditorFieldRows(editor: AgentWorkspaceLocalEditor, index: number, width: number): WorkspaceRow[] {
+  const field = editor.fields[index]!;
+  const selected = index === editor.selectedFieldIndex;
+  const marker = selected ? GLYPHS.navigation.selected : ' ';
+  const required = field.required ? ' *' : '';
+  const value = field.value.length > 0 ? field.value : '(empty)';
+  const color = selected ? PALETTE.text : field.value.length > 0 ? PALETTE.info : PALETTE.muted;
+  const rows: WorkspaceRow[] = [{
+    text: `${marker} ${field.label}${required}`,
+    selected,
+    fg: color,
+    bold: selected,
+  }];
+  const valueLines = value.split('\n');
+  for (const valueLine of valueLines.slice(0, 4)) {
+    for (const wrapped of wrapText(`  ${valueLine}`, Math.max(1, width - 2))) {
+      rows.push({ text: wrapped, fg: field.value.length > 0 ? PALETTE.text : PALETTE.dim, dim: field.value.length === 0 });
+    }
+  }
+  if (valueLines.length > 4) rows.push({ text: `  ${valueLines.length - 4} more line(s)`, fg: PALETTE.dim, dim: true });
+  rows.push({ text: `  ${field.hint}`, fg: PALETTE.dim, dim: true });
+  return rows;
+}
+
 function buildActionRows(workspace: AgentWorkspace, width: number, height: number): WorkspaceRow[] {
   if (workspace.localEditor) return buildEditorRows(workspace.localEditor, width, height);
   const rows: WorkspaceRow[] = [];

package/src/renderer/help-overlay.ts

@@ -78,7 +78,7 @@ export function renderHelpOverlay(
     ['routines',     '',           'Manage reusable main-conversation routines'],
     ['workplan',     '',           'Inspect shared work-plan state'],
     ['approval',     '',           'Review and explicitly act on approvals'],
-    ['schedule',     '',           'Inspect schedules and routine promotion receipts'],
+    ['schedule',     'remind',     'Create confirmed reminders or inspect schedules'],
     ['delegate',     '',           'Explicitly hand build/fix/review work to GoodVibes TUI'],
     ['mcp',          '',           'Inspect MCP servers and tool readiness'],
     ['provider',     '',           'Choose provider or model family'],