@pellux/goodvibes-agent 0.1.106 → 0.1.108

package/src/cli/parser.ts

@@ -7,7 +7,6 @@ import type {
 
 const COMMAND_ALIASES: Readonly<Record<string, GoodVibesCliCommand>> = {
   tui: 'tui',
-  app: 'tui',
   run: 'run',
   exec: 'run',
   e: 'run',
@@ -61,6 +60,8 @@ const COMMAND_ALIASES: Readonly<Record<string, GoodVibesCliCommand>> = {
   version: 'version',
 };
 
+const RETIRED_LAUNCHER_ALIASES = new Set(['app', 'launch', 'start']);
+
 function createDefaultFlags(): GoodVibesCliFlags {
   return {
     provider: undefined,
@@ -201,7 +202,14 @@ export function parseGoodVibesCli(
 
     if (!token.startsWith('-') || token === '-') {
       if (!sawCommand) {
-        const normalized = COMMAND_ALIASES[token.toLowerCase()];
+        const commandToken = token.toLowerCase();
+        if (RETIRED_LAUNCHER_ALIASES.has(commandToken)) {
+          command = 'unknown';
+          rawCommand = token;
+          sawCommand = true;
+          continue;
+        }
+        const normalized = COMMAND_ALIASES[commandToken];
         if (normalized) {
           command = normalized;
           rawCommand = token;

package/src/cli/service-posture.ts

@@ -143,7 +143,7 @@ function resolveConfiguredLogPath(runtime: CliServiceRuntime): string | undefine
 function createExternalDaemonLifecycle(logPath: string | undefined): CliExternalDaemonLifecyclePosture {
   return {
     platform: 'manual',
-    path: 'external GoodVibes runtime host',
+    path: 'connected GoodVibes services',
     installed: false,
     autostart: false,
     running: false,
@@ -151,7 +151,7 @@ function createExternalDaemonLifecycle(logPath: string | undefined): CliExternal
     commandPreview: 'managed outside goodvibes-agent',
     suggestedCommands: [],
     lastAction: 'status',
-    pidPath: 'external GoodVibes runtime host',
+    pidPath: 'connected GoodVibes services',
     lastError: null,
   };
 }
@@ -184,13 +184,13 @@ export async function buildCliServicePosture(
   const issues: string[] = [];
 
   if (serverBackedEnabled && !config.enabled) {
-    issues.push('External runtime connection settings are present, but Agent runtime lifecycle ownership is disabled by design.');
+    issues.push('Connected-service settings are present, but Agent service ownership is disabled by design.');
   }
   if (config.enabled && !config.autostart) {
-    issues.push('External runtime host config has autostart off.');
+    issues.push('Connected-service autostart is off.');
   }
   if (config.enabled && !config.restartOnFailure) {
-    issues.push('External runtime host config has restart-on-failure off.');
+    issues.push('Connected-service restart-on-failure is off.');
   }
   for (const endpoint of endpoints) {
     if (endpoint.enabled && options.probe && endpoint.reachable === false) {
@@ -239,7 +239,7 @@ export function formatCliServicePosture(posture: CliServicePosture, json = false
     `  log: ${posture.log.path ?? 'n/a'} (${posture.log.exists ? 'present' : 'missing'})`,
     ...(posture.log.readError ? [`  log read error: ${posture.log.readError}`] : []),
     '',
-    'Runtime connection checks:',
+    'Connected GoodVibes API checks:',
     ...posture.endpoints.map((endpoint) =>
       `  ${endpoint.label}: enabled=${yesNo(endpoint.enabled)} ${endpoint.binding.hostMode} ${endpoint.binding.host}:${endpoint.binding.port} posture=${endpoint.bindPosture.label}${endpoint.reachable === undefined ? '' : ` reachable=${yesNo(endpoint.reachable)}`}`,
     ),

package/src/cli/status.ts

@@ -126,20 +126,20 @@ export function buildCliDoctorFindings(options: CliStatusOptions): readonly CliD
         id: 'external-runtime-unreachable',
         area: 'runtime',
         severity: 'warning',
-        summary: 'External GoodVibes runtime is not reachable.',
+        summary: 'Connected GoodVibes services are not reachable.',
         cause: `Agent could not reach ${options.externalRuntime.baseUrl}${options.externalRuntime.error ? `: ${options.externalRuntime.error}` : '.'}`,
-        impact: 'Companion chat, isolated Agent Knowledge, approvals, automation status, and build delegation cannot work until the external runtime is available.',
-        action: 'Start or repair the runtime-owning GoodVibes TUI/host, then rerun goodvibes-agent status.',
+        impact: 'Companion chat, isolated Agent Knowledge, approvals, automation status, and build delegation cannot work until connected GoodVibes services are available.',
+        action: 'Start or repair the owning GoodVibes host, then rerun goodvibes-agent status.',
       });
     } else if (!options.externalRuntime.compatible) {
       findings.push({
         id: 'external-runtime-version-mismatch',
         area: 'runtime',
         severity: 'warning',
-        summary: 'External GoodVibes runtime SDK version does not match Agent.',
-        cause: `Runtime reports SDK ${options.externalRuntime.version}; Agent expects ${options.externalRuntime.expectedVersion}.`,
+        summary: 'Connected GoodVibes service SDK version does not match Agent.',
+        cause: `Connected service reports SDK ${options.externalRuntime.version}; Agent expects ${options.externalRuntime.expectedVersion}.`,
         impact: 'Agent-only routes, especially isolated Agent Knowledge, may be missing or incompatible.',
-        action: 'Update/restart the runtime-owning GoodVibes TUI/host so /status matches this Agent package SDK pin.',
+        action: 'Update the owning GoodVibes host so /status matches this Agent package SDK pin.',
       });
     }
 
@@ -148,10 +148,10 @@ export function buildCliDoctorFindings(options: CliStatusOptions): readonly CliD
         id: 'external-runtime-token-missing',
         area: 'auth',
         severity: 'warning',
-        summary: 'External runtime operator token is missing.',
+        summary: 'Connected-service operator token is missing.',
         cause: `No operator token was found at ${options.externalRuntime.operatorToken.path}.`,
-        impact: 'Agent can inspect only unauthenticated routes and cannot use protected runtime APIs.',
-        action: 'Pair or provision access through the runtime-owning GoodVibes TUI/host, then rerun goodvibes-agent auth.',
+        impact: 'Agent can inspect only unauthenticated routes and cannot use protected connected-service APIs.',
+        action: 'Pair or provision access through the owning GoodVibes host, then rerun goodvibes-agent auth.',
       });
     }
 
@@ -163,7 +163,7 @@ export function buildCliDoctorFindings(options: CliStatusOptions): readonly CliD
         summary: 'Isolated Agent Knowledge route is not ready.',
         cause: `${options.externalRuntime.agentKnowledge.route} returned ${options.externalRuntime.agentKnowledge.kind}${options.externalRuntime.agentKnowledge.statusCode === null ? '' : ` (${options.externalRuntime.agentKnowledge.statusCode})`}.`,
         impact: 'Agent Knowledge ask/search will not use any fallback wiki or non-Agent knowledge segment; it will fail closed until the Agent route is available.',
-        action: 'Update/restart the external runtime to the Agent-compatible SDK and verify goodvibes-agent compat.',
+        action: 'Update the connected GoodVibes services to the Agent-compatible SDK and verify goodvibes-agent compat.',
       });
     }
   }
@@ -173,10 +173,10 @@ export function buildCliDoctorFindings(options: CliStatusOptions): readonly CliD
       id: 'runtime-ownership-external',
       area: 'runtime',
       severity: 'warning',
-      summary: 'External runtime connection settings are present while Agent lifecycle ownership is disabled by design.',
-      cause: 'One or more runtime connection, inbound events, or browser companion settings are enabled while service.enabled is false.',
-      impact: 'The external GoodVibes runtime must own availability for those endpoints; Agent will not start or enable them.',
-      action: 'Manage runtime availability from GoodVibes TUI or the owning host, then use Agent for read-only diagnostics.',
+      summary: 'Connected-service settings are present while Agent service ownership is disabled by design.',
+      cause: 'One or more connected API, inbound events, or browser companion settings are enabled while service.enabled is false.',
+      impact: 'The owning GoodVibes host must provide availability for those endpoints; Agent will not start or enable them.',
+      action: 'Manage connected-service availability from GoodVibes TUI or the owning host, then use Agent for read-only diagnostics.',
     });
   }
 
@@ -185,9 +185,9 @@ export function buildCliDoctorFindings(options: CliStatusOptions): readonly CliD
       id: 'runtime-autostart-disabled',
       area: 'runtime',
       severity: 'warning',
-      summary: 'External runtime host config has autostart off.',
+      summary: 'Connected-service autostart is off.',
       cause: 'service.enabled is true and service.autostart is false.',
-      impact: 'The external GoodVibes runtime may not be available after login or reboot even though host-managed startup is selected.',
+      impact: 'Connected GoodVibes services may not be available after login or reboot even though host-managed startup is selected.',
       action: 'Configure autostart from GoodVibes TUI or the owning host; Agent will not mutate this setting.',
     });
   }
@@ -197,9 +197,9 @@ export function buildCliDoctorFindings(options: CliStatusOptions): readonly CliD
       id: 'runtime-restart-disabled',
       area: 'runtime',
       severity: 'warning',
-      summary: 'External runtime host config has restart-on-failure off.',
+      summary: 'Connected-service restart-on-failure is off.',
       cause: 'service.enabled is true and service.restartOnFailure is false.',
-      impact: 'A crashed runtime or listener may stay down until manually restarted.',
+      impact: 'A crashed connected service or listener may stay down until manually restarted.',
       action: 'Configure restart-on-failure from GoodVibes TUI or the owning host; Agent will not mutate this setting.',
     });
   }
@@ -212,9 +212,9 @@ export function buildCliDoctorFindings(options: CliStatusOptions): readonly CliD
         area: 'runtime',
         severity: 'warning',
         summary: issue,
-        cause: 'The runtime connection inspection found a mismatch between configured endpoint state and observed host state.',
-        impact: 'Runtime API, listener, or web availability may not match the configuration.',
-        action: 'Use Agent status and doctor diagnostics here, then manage the runtime from GoodVibes TUI or your host tooling.',
+        cause: 'The connected-service inspection found a mismatch between configured endpoint state and observed host state.',
+        impact: 'Connected API, listener, or web availability may not match the configuration.',
+        action: 'Use Agent status and doctor diagnostics here, then manage connected services outside Agent.',
       });
     }
   }
@@ -226,7 +226,7 @@ export function buildCliDoctorFindings(options: CliStatusOptions): readonly CliD
       severity: 'warning',
       summary: 'Agent setup has not been shown for this user.',
       cause: 'No global user setup check marker was found.',
-      impact: 'Important runtime, network, provider, auth, or permission choices may still be implicit defaults.',
+      impact: 'Important connected-service, network, provider, auth, or permission choices may still be implicit defaults.',
       action: 'Run /setup in GoodVibes Agent or goodvibes-agent setup status to review setup state.',
     });
   }
@@ -236,10 +236,10 @@ export function buildCliDoctorFindings(options: CliStatusOptions): readonly CliD
       id: 'network-endpoint-without-runtime-auth-signal',
       area: 'auth',
       severity: 'risk',
-      summary: 'Network-facing runtime endpoints are enabled without a visible runtime auth signal.',
-      cause: `${networkFacingSurfaces.map(([name]) => name).join(', ')} are LAN/custom-bound, but Agent cannot see runtime auth state from its local compatibility files.`,
-      impact: 'Remote access paths may be unusable or unsafe unless the external runtime owner configured auth.',
-      action: 'Review runtime auth from the owning GoodVibes TUI or host tooling; Agent will not create local runtime users.',
+      summary: 'Network-facing connected-service endpoints are enabled without a visible auth signal.',
+      cause: `${networkFacingSurfaces.map(([name]) => name).join(', ')} are LAN/custom-bound, but Agent cannot see connected-service auth state from its local compatibility files.`,
+      impact: 'Remote access paths may be unusable or unsafe unless the owning host configured auth.',
+      action: 'Review connected-service auth outside Agent; Agent will not create local service users.',
     });
   }
 
@@ -251,7 +251,7 @@ export function buildCliDoctorFindings(options: CliStatusOptions): readonly CliD
       summary: 'A bootstrap credential is still present while network-facing surfaces are enabled.',
       cause: `${networkFacingSurfaces.map(([name]) => name).join(', ')} are LAN/custom-bound and auth-bootstrap.txt exists.`,
       impact: 'Bootstrap credentials should be treated as temporary setup material, not long-lived network access credentials.',
-      action: 'Use the runtime-owning GoodVibes TUI or host tooling to replace bootstrap auth and retire the bootstrap credential.',
+      action: 'Replace bootstrap auth and retire the bootstrap credential outside Agent.',
     });
   }
 
@@ -379,7 +379,7 @@ export function renderCliStatus(options: CliStatusOptions): string {
       ? `  operatorTokens: ${options.auth.operatorTokenPresent ? 'present' : 'missing'} (${options.auth.operatorTokenPath})`
       : '  operatorTokens: unknown',
     '',
-    'Runtime Connection:',
+    'Connected GoodVibes API:',
     ...(externalRuntime ? [
       `  baseUrl: ${externalRuntime.baseUrl}`,
       `  reachable: ${yesNo(externalRuntime.reachable)}${externalRuntime.statusCode === null ? '' : ` (HTTP ${externalRuntime.statusCode})`}`,
@@ -392,10 +392,10 @@ export function renderCliStatus(options: CliStatusOptions): string {
       '  live check: unavailable',
     ]),
     '',
-    'Runtime Ownership:',
+    'Connected GoodVibes Services:',
     '  Agent role: client/operator TUI only',
-    '  hosting lifecycle: external',
-    '  Agent starts runtime: no',
+    '  service ownership: outside Agent',
+    '  Agent starts services: no',
     ...(options.service ? [
       `  platform: ${options.service.managed.platform}`,
       `  installed: ${yesNo(options.service.managed.installed)}`,
@@ -412,7 +412,7 @@ export function renderCliStatus(options: CliStatusOptions): string {
   if (options.doctor) {
     lines.push(
       '',
-      'External Runtime Config Signals:',
+      'Connected-Service Config Signals:',
       `  host config present: ${yesNo(serviceEnabled)}`,
       `  host autostart: ${yesNo(serviceAutostart)}`,
       `  host restart policy: ${yesNo(restartOnFailure)}`,

package/src/cli/tui-startup.ts

@@ -100,6 +100,7 @@ export function applyInitialTuiCliState(options: {
 }): void {
   const { cli, input, commandRegistry, commandContext, shellPaths, render } = options;
   const globalOnboardingMarker = readOnboardingCheckMarker(shellPaths, 'user');
+  const seededPrompt = cli.flags.prompt ?? (cli.rawCommand === undefined && cli.positionals.length > 0 ? cli.positionals.join(' ') : undefined);
   if (cli.command === 'onboarding') {
     input.openOnboardingWizard({ mode: 'edit', reset: true });
   } else if (cli.command === 'sessions' && cli.commandArgs[0] === 'resume') {
@@ -109,9 +110,10 @@ export function applyInitialTuiCliState(options: {
     }
   } else if (!globalOnboardingMarker.exists) {
     input.openOnboardingWizard({ mode: 'new', reset: true });
+  } else if (cli.command === 'tui' && seededPrompt === undefined) {
+    input.openAgentWorkspace(commandContext);
   }
 
-  const seededPrompt = cli.flags.prompt ?? (cli.rawCommand === undefined && cli.positionals.length > 0 ? cli.positionals.join(' ') : undefined);
   if (seededPrompt) {
     input.prompt = seededPrompt;
     input.cursorPos = seededPrompt.length;

package/src/input/agent-workspace-activation.ts

@@ -1,4 +1,9 @@
 import { createLocalEditor, createProfileEditor } from './agent-workspace-editors.ts';
+import { createAgentWorkspaceBasicCommandEditor, isAgentWorkspaceBasicCommandEditorKind } from './agent-workspace-basic-command-editors.ts';
+import { createAgentKnowledgeQueryEditor } from './agent-workspace-knowledge-query-editor.ts';
+import { createReminderScheduleEditor } from './agent-workspace-reminder-schedule-editor.ts';
+import { createRoutineScheduleEditor } from './agent-workspace-routine-schedule-editor.ts';
+import { parseSlashCommand } from './slash-command-parser.ts';
 import type {
   AgentWorkspaceActionResult,
   AgentWorkspaceCategory,
@@ -6,6 +11,7 @@ import type {
   AgentWorkspaceFocusPane,
   AgentWorkspaceLocalEditor,
   AgentWorkspaceLocalEditorKind,
+  AgentWorkspaceLocalLibraryItem,
   AgentWorkspaceLocalOperation,
   AgentWorkspaceRuntimeSnapshot,
 } from './agent-workspace-types.ts';
@@ -25,18 +31,12 @@ interface AgentWorkspaceActivationHost {
   focusActions(): void;
   clampSelection(): void;
   moveLocalLibraryItemSelection(kind: AgentWorkspaceLocalEditorKind, delta: number): void;
+  selectedLocalLibraryItem(kind: AgentWorkspaceLocalEditorKind): AgentWorkspaceLocalLibraryItem | null;
   applyLocalLibraryOperation(operation: AgentWorkspaceLocalOperation): void;
   hasCommandDispatch(): boolean;
   dispatchWorkspaceCommand: AgentWorkspaceCommandDispatcher;
 }
 
-function parseCommand(command: string): { readonly name: string; readonly args: readonly string[] } {
-  const trimmed = command.trim().replace(/^\//, '');
-  if (!trimmed) return { name: '', args: [] };
-  const parts = trimmed.split(/\s+/);
-  return { name: parts[0] ?? '', args: parts.slice(1) };
-}
-
 export function activateAgentWorkspaceSelection(
   workspace: AgentWorkspaceActivationHost,
   requestRender?: () => void,
@@ -52,9 +52,7 @@ export function activateAgentWorkspaceSelection(
   const action = workspace.selectedAction;
   if (!action) return;
   if (action.kind === 'editor' && action.editorKind) {
-    workspace.localEditor = action.editorKind === 'profile'
-      ? createProfileEditor(workspace.runtimeSnapshot?.runtimeStarterTemplates ?? [])
-      : createLocalEditor(action.editorKind);
+    workspace.localEditor = createWorkspaceEditor(workspace, action.editorKind);
     workspace.status = `Editing ${workspace.localEditor.title}.`;
     workspace.lastActionResult = {
       kind: 'guidance',
@@ -87,7 +85,7 @@ export function activateAgentWorkspaceSelection(
     };
     return;
   }
-  const parsed = parseCommand(action.command);
+  const parsed = parseSlashCommand(action.command);
   if (!parsed.name) {
     workspace.status = `No command is configured for ${action.label}.`;
     workspace.lastActionResult = {
@@ -99,11 +97,11 @@ export function activateAgentWorkspaceSelection(
     return;
   }
   if (/<[^>\s]+(?:\s+[^>]*)?>/.test(action.command)) {
-    workspace.status = `Placeholder command not dispatched: ${action.command}.`;
+    workspace.status = `Command needs concrete values before dispatch: ${action.command}.`;
     workspace.lastActionResult = {
       kind: 'guidance',
       title: `${action.label} needs details`,
-      detail: 'This action is a command template. Close the workspace and run it with real task text instead of placeholder values.',
+      detail: 'This action needs concrete values before it can run. Return to the composer and include the real task text.',
       command: action.command,
       safety: action.safety,
     };
@@ -131,6 +129,19 @@ export function activateAgentWorkspaceSelection(
   workspace.dispatchWorkspaceCommand(action.command);
 }
 
+function createWorkspaceEditor(
+  workspace: AgentWorkspaceActivationHost,
+  editorKind: AgentWorkspaceCategory['actions'][number]['editorKind'],
+): AgentWorkspaceLocalEditor {
+  if (editorKind === 'profile') return createProfileEditor(workspace.runtimeSnapshot?.runtimeStarterTemplates ?? []);
+  if (editorKind && isAgentWorkspaceBasicCommandEditorKind(editorKind)) return createAgentWorkspaceBasicCommandEditor(editorKind);
+  if (editorKind === 'knowledge-ask') return createAgentKnowledgeQueryEditor('ask');
+  if (editorKind === 'knowledge-search') return createAgentKnowledgeQueryEditor('search');
+  if (editorKind === 'reminder-schedule') return createReminderScheduleEditor();
+  if (editorKind === 'routine-schedule') return createRoutineScheduleEditor(workspace.selectedLocalLibraryItem('routine'));
+  return createLocalEditor(editorKind ?? 'memory');
+}
+
 function handleGuidanceOrWorkspaceAction(
   workspace: AgentWorkspaceActivationHost,
   action: AgentWorkspaceCategory['actions'][number],