@pellux/goodvibes-agent 1.1.3 → 1.1.5

package/src/input/agent-workspace-host-category.ts

@@ -0,0 +1,57 @@
+import type { AgentWorkspaceCategory } from './agent-workspace-types.ts';
+
+export const AGENT_WORKSPACE_HOST_CATEGORY: AgentWorkspaceCategory = {
+  id: 'host',
+  group: 'OPERATIONS',
+  label: 'Connected Host',
+  summary: 'Connected-host health, tasks, sessions, channels, and automation.',
+  detail: 'Use this workspace to inspect the GoodVibes host surfaces that Agent can see: system health, remote routes, host tasks, sessions, channels, schedules, knowledge, media, MCP, provider auth, support bundles, and telemetry/config posture.',
+  actions: [
+    { id: 'host-overview', label: 'Host overview', detail: 'Review connected-host, provider, settings, continuity, and Agent health without starting or mutating host work.', command: '/health review', kind: 'command', safety: 'read-only' },
+    { id: 'host-services', label: 'Host services', detail: 'Inspect connected-host service readiness, credentials, and integration issues without changing them.', command: '/health host', kind: 'command', safety: 'read-only' },
+    { id: 'host-setup', label: 'Setup review', detail: 'Inspect setup issues that affect connected-host and Agent runtime readiness.', command: '/health setup', kind: 'command', safety: 'read-only' },
+    { id: 'host-remote', label: 'Remote routes', detail: 'Inspect remote build-host route health and recovery signals without starting build work.', command: '/health remote', kind: 'command', safety: 'read-only' },
+    { id: 'host-maintenance', label: 'Session maintenance', detail: 'Review continuity, compaction, and current-session maintenance posture.', command: '/health maintenance', kind: 'command', safety: 'read-only' },
+    { id: 'host-continuity', label: 'Continuity', detail: 'Inspect last-session pointer, recovery-file posture, and return-context state.', command: '/health continuity', kind: 'command', safety: 'read-only' },
+    { id: 'host-tasks', label: 'Host tasks', detail: 'Inspect connected-host task state without creating, retrying, or mutating tasks.', command: '/tasks list', kind: 'command', safety: 'read-only' },
+    { id: 'host-task-filter', label: 'Filter host tasks', detail: 'Open a status/type form for read-only connected-host task filtering.', editorKind: 'task-list-filter', kind: 'editor', safety: 'read-only' },
+    { id: 'host-task-show', label: 'Inspect host task', detail: 'Open a task-id form for read-only connected-host task metadata.', editorKind: 'task-show', kind: 'editor', safety: 'read-only' },
+    { id: 'host-task-output', label: 'Show task output', detail: 'Open a task-id form for read-only connected-host task output.', editorKind: 'task-output', kind: 'editor', safety: 'read-only' },
+    { id: 'host-sessions', label: 'Host session routes', detail: 'Browse saved Agent sessions and return-context posture exposed through the runtime session surface.', command: '/session list', kind: 'command', safety: 'read-only' },
+    { id: 'host-session-graph', label: 'Session graph', detail: 'Open a read-only form for cross-session graph inspection; graph mutation remains blocked in Agent.', editorKind: 'session-graph', kind: 'editor', safety: 'read-only' },
+    { id: 'host-channels-status', label: 'Channel status', detail: 'Inspect connected channel runtime status from the host without mutating delivery state.', command: '/channels status', kind: 'command', safety: 'read-only' },
+    { id: 'host-channel-accounts', label: 'Channel accounts', detail: 'Inspect connected channel accounts without printing secret values or sending messages.', command: '/channels accounts', kind: 'command', safety: 'read-only' },
+    { id: 'host-channel-policies', label: 'Channel policies', detail: 'Inspect channel delivery policy posture without changing routing.', command: '/channels policies', kind: 'command', safety: 'read-only' },
+    { id: 'host-channels', label: 'Open Channels', detail: 'Jump to the channel setup and delivery workspace.', targetCategoryId: 'channels', kind: 'workspace', safety: 'safe' },
+    { id: 'host-automation', label: 'Open Automation', detail: 'Jump to connected schedules, reminders, receipts, and explicit run controls.', targetCategoryId: 'automation', kind: 'workspace', safety: 'safe' },
+    { id: 'host-schedules', label: 'Schedule status', detail: 'Inspect schedules and run history without running or mutating them.', command: '/schedule list', kind: 'command', safety: 'read-only' },
+    { id: 'host-schedule-reconcile', label: 'Reconcile schedules', detail: 'Compare local promotion receipts with live connected schedules.', command: '/schedule reconcile', kind: 'command', safety: 'read-only' },
+    { id: 'host-knowledge', label: 'Knowledge route', detail: 'Inspect isolated Agent Knowledge route readiness and source counts.', command: '/knowledge status', kind: 'command', safety: 'read-only' },
+    { id: 'host-knowledge-open', label: 'Open Knowledge', detail: 'Jump to Agent Knowledge source, graph, review, and ingest controls.', targetCategoryId: 'knowledge', kind: 'workspace', safety: 'safe' },
+    { id: 'host-media', label: 'Media providers', detail: 'Inspect configured media providers before generating media with confirmation.', command: '/media providers', kind: 'command', safety: 'read-only' },
+    { id: 'host-media-open', label: 'Open Voice and Media', detail: 'Jump to voice, TTS, image input, media provider, and browser-tool setup actions.', targetCategoryId: 'voice-media', kind: 'workspace', safety: 'safe' },
+    { id: 'host-mcp-health', label: 'MCP health', detail: 'Inspect MCP lifecycle issues without changing trust posture or approving tool-definition review.', command: '/health mcp', kind: 'command', safety: 'read-only' },
+    { id: 'host-mcp-review', label: 'MCP review', detail: 'Inspect MCP server connection, trust, role, and review posture.', command: '/mcp review', kind: 'command', safety: 'read-only' },
+    { id: 'host-tools-open', label: 'Open Tools and MCP', detail: 'Jump to MCP server setup, tool inventory, secrets, and security review.', targetCategoryId: 'tools', kind: 'workspace', safety: 'safe' },
+    { id: 'host-provider-accounts', label: 'Provider accounts', detail: 'Review provider account routes, subscription windows, and billing-path safety.', command: '/accounts review', kind: 'command', safety: 'read-only' },
+    { id: 'host-provider-detail', label: 'Provider detail', detail: 'Open a provider-id form for account and provider configuration review.', editorKind: 'provider-inspect', kind: 'editor', safety: 'read-only' },
+    { id: 'host-provider-routes', label: 'Provider routes', detail: 'Open a provider-id form for account, subscription, and route inspection.', editorKind: 'provider-routes', kind: 'editor', safety: 'read-only' },
+    { id: 'host-provider-repair', label: 'Provider repair guidance', detail: 'Open a provider-id form for read-only provider repair guidance.', editorKind: 'provider-account-repair', kind: 'editor', safety: 'read-only' },
+    { id: 'host-auth-owner', label: 'Connected-host auth owner', detail: 'Show that connected-host auth administration belongs to the owning GoodVibes host, not Agent.', command: '/auth local', kind: 'command', safety: 'read-only' },
+    { id: 'host-auth-review', label: 'Provider auth review', detail: 'Review provider auth posture without printing token values.', command: '/auth review', kind: 'command', safety: 'read-only' },
+    { id: 'host-auth-detail', label: 'Provider auth detail', detail: 'Open a provider-id form for read-only provider auth inspection.', editorKind: 'auth-show', kind: 'editor', safety: 'read-only' },
+    { id: 'host-auth-repair', label: 'Provider auth repair', detail: 'Open a provider-id form for provider auth repair guidance.', editorKind: 'auth-repair', kind: 'editor', safety: 'read-only' },
+    { id: 'host-auth-bundle-export', label: 'Export auth bundle', detail: 'Open a confirmed form that exports a redacted provider auth review bundle.', editorKind: 'auth-bundle-export', kind: 'editor', safety: 'safe' },
+    { id: 'host-auth-bundle-inspect', label: 'Inspect auth bundle', detail: 'Open a form that inspects a provider auth review bundle before sharing or import.', editorKind: 'auth-bundle-inspect', kind: 'editor', safety: 'read-only' },
+    { id: 'host-subscription-bundle-export', label: 'Export subscription bundle', detail: 'Open a confirmed form that exports redacted provider subscription state for review.', editorKind: 'subscription-bundle-export', kind: 'editor', safety: 'safe' },
+    { id: 'host-subscription-bundle-inspect', label: 'Inspect subscription bundle', detail: 'Open a form that inspects provider subscription state before sharing.', editorKind: 'subscription-bundle-inspect', kind: 'editor', safety: 'read-only' },
+    { id: 'host-security', label: 'Security review', detail: 'Inspect token posture, MCP attack paths, policy lint, plugin risk, and incident pressure.', command: '/security review', kind: 'command', safety: 'read-only' },
+    { id: 'host-trust', label: 'Trust review', detail: 'Review permission, secret, plugin, and MCP trust posture without exporting bundles or changing trust.', command: '/trust review', kind: 'command', safety: 'read-only' },
+    { id: 'host-support-bundle-export', label: 'Export support bundle', detail: 'Export a redacted Agent support bundle from the Host page.', editorKind: 'support-bundle-export', kind: 'editor', safety: 'safe' },
+    { id: 'host-support-bundle-inspect', label: 'Inspect support bundle', detail: 'Inspect a support bundle before import or sharing.', editorKind: 'support-bundle-inspect', kind: 'editor', safety: 'read-only' },
+    { id: 'host-support-bundle-import', label: 'Import support bundle', detail: 'Import reviewed, non-redacted config values from a support bundle.', editorKind: 'support-bundle-import', kind: 'editor', safety: 'safe' },
+    { id: 'host-telemetry', label: 'Telemetry settings', detail: 'Open telemetry payload policy settings for connected-host and Agent observability review.', command: '/config telemetry', kind: 'command', safety: 'safe' },
+    { id: 'host-config', label: 'Control-plane settings', detail: 'Open configuration controls for service, channels, tools, automation, provider, and storage posture.', command: '/config', kind: 'command', safety: 'safe' },
+    { id: 'host-safety', label: 'Host mutation policy', detail: 'Agent may inspect connected-host surfaces and run explicit confirmed actions, but does not silently create tasks, send channel messages, mutate auth, or start automation.', kind: 'guidance', safety: 'blocked' },
+  ],
+};

package/src/input/agent-workspace-local-editor-submission.ts

@@ -0,0 +1,193 @@
+import type { ShellPathService } from '@/runtime/index.ts';
+import { AgentNoteRegistry } from '../agent/note-registry.ts';
+import { AgentPersonaRegistry } from '../agent/persona-registry.ts';
+import { AgentRoutineRegistry } from '../agent/routine-registry.ts';
+import { createAgentRuntimeProfile, type AgentRuntimeProfileInfo } from '../agent/runtime-profile.ts';
+import { AgentSkillRegistry } from '../agent/skill-registry.ts';
+import { createAgentWorkspaceLearnedBehavior } from './agent-workspace-learned-behavior.ts';
+import { buildAgentWorkspaceRequirements } from './agent-workspace-requirements.ts';
+import { isAffirmative, splitList } from './agent-workspace-editors.ts';
+import type { AgentWorkspaceLocalEditor, AgentWorkspaceLocalEditorKind } from './agent-workspace-types.ts';
+
+type LearnedBehaviorTarget = Exclude<AgentWorkspaceLocalEditorKind, 'memory' | 'note' | 'profile'>;
+
+export interface AgentWorkspaceLocalEditorSubmissionCallbacks {
+  readonly readField: (id: string) => string;
+  readonly learnedBehaviorTarget: () => LearnedBehaviorTarget;
+  readonly submitDeleteEditor: () => void;
+  readonly finishLocalEditor: (kind: AgentWorkspaceLocalEditorKind, id: string, name: string, verb: 'Created' | 'Updated') => void;
+  readonly finishProfileEditor: (profile: AgentRuntimeProfileInfo) => void;
+}
+
+export function submitAgentWorkspaceLocalRegistryEditor(
+  shellPaths: ShellPathService,
+  editor: AgentWorkspaceLocalEditor,
+  callbacks: AgentWorkspaceLocalEditorSubmissionCallbacks,
+): void {
+  const field = callbacks.readField;
+  if (editor.mode === 'delete') {
+    callbacks.submitDeleteEditor();
+    return;
+  }
+  if (editor.kind === 'learned-behavior') {
+    const created = createAgentWorkspaceLearnedBehavior(shellPaths, {
+      target: callbacks.learnedBehaviorTarget(),
+      name: field('name'),
+      description: field('description'),
+      notes: field('notes'),
+      tags: splitList(field('tags')),
+      triggers: splitList(field('triggers')),
+      enable: isAffirmative(field('enable')),
+    });
+    callbacks.finishLocalEditor(created.kind, created.id, created.name, 'Created');
+  } else if (editor.kind === 'profile') {
+    const template = field('template');
+    const templateId = template && template.toLowerCase() !== 'none' ? template : undefined;
+    const profile = createAgentRuntimeProfile(shellPaths.homeDirectory, field('name'), {
+      ...(templateId ? { templateId } : {}),
+    });
+    callbacks.finishProfileEditor(profile);
+  } else if (editor.kind === 'note') {
+    submitNoteEditor(shellPaths, editor, field, callbacks.finishLocalEditor);
+  } else if (editor.kind === 'persona') {
+    submitPersonaEditor(shellPaths, editor, field, callbacks.finishLocalEditor);
+  } else if (editor.kind === 'skill') {
+    submitSkillEditor(shellPaths, editor, field, callbacks.finishLocalEditor);
+  } else {
+    submitRoutineEditor(shellPaths, editor, field, callbacks.finishLocalEditor);
+  }
+}
+
+function submitNoteEditor(
+  shellPaths: ShellPathService,
+  editor: AgentWorkspaceLocalEditor,
+  field: (id: string) => string,
+  finish: AgentWorkspaceLocalEditorSubmissionCallbacks['finishLocalEditor'],
+): void {
+  const registry = AgentNoteRegistry.fromShellPaths(shellPaths);
+  if (editor.mode === 'update' && editor.recordId) {
+    const updated = registry.update(editor.recordId, {
+      title: field('title'),
+      body: field('body'),
+      sourceUrl: field('sourceUrl'),
+      tags: splitList(field('tags')),
+      provenance: 'Workspace',
+    });
+    finish('note', updated.id, updated.title, 'Updated');
+    return;
+  }
+  const created = registry.create({
+    title: field('title'),
+    body: field('body'),
+    sourceUrl: field('sourceUrl'),
+    tags: splitList(field('tags')),
+    source: 'user',
+    provenance: 'Workspace',
+  });
+  finish('note', created.id, created.title, 'Created');
+}
+
+function submitPersonaEditor(
+  shellPaths: ShellPathService,
+  editor: AgentWorkspaceLocalEditor,
+  field: (id: string) => string,
+  finish: AgentWorkspaceLocalEditorSubmissionCallbacks['finishLocalEditor'],
+): void {
+  const registry = AgentPersonaRegistry.fromShellPaths(shellPaths);
+  if (editor.mode === 'update' && editor.recordId) {
+    const wasActive = registry.snapshot().activePersonaId === editor.recordId;
+    const updated = registry.update(editor.recordId, {
+      name: field('name'),
+      description: field('description'),
+      body: field('body'),
+      tags: splitList(field('tags')),
+      triggers: splitList(field('triggers')),
+      provenance: 'Workspace',
+    });
+    if (isAffirmative(field('activate'))) registry.setActive(updated.id);
+    else if (wasActive) registry.clearActive();
+    finish('persona', updated.id, updated.name, 'Updated');
+    return;
+  }
+  const created = registry.create({
+    name: field('name'),
+    description: field('description'),
+    body: field('body'),
+    tags: splitList(field('tags')),
+    triggers: splitList(field('triggers')),
+    source: 'user',
+    provenance: 'Workspace',
+  });
+  if (isAffirmative(field('activate'))) registry.setActive(created.id);
+  finish('persona', created.id, created.name, 'Created');
+}
+
+function submitSkillEditor(
+  shellPaths: ShellPathService,
+  editor: AgentWorkspaceLocalEditor,
+  field: (id: string) => string,
+  finish: AgentWorkspaceLocalEditorSubmissionCallbacks['finishLocalEditor'],
+): void {
+  const registry = AgentSkillRegistry.fromShellPaths(shellPaths);
+  if (editor.mode === 'update' && editor.recordId) {
+    const updated = registry.update(editor.recordId, {
+      name: field('name'),
+      description: field('description'),
+      procedure: field('procedure'),
+      triggers: splitList(field('triggers')),
+      tags: splitList(field('tags')),
+      requirements: buildAgentWorkspaceRequirements(field),
+      provenance: 'Workspace',
+    });
+    registry.setEnabled(updated.id, isAffirmative(field('enabled')));
+    finish('skill', updated.id, updated.name, 'Updated');
+    return;
+  }
+  const created = registry.create({
+    name: field('name'),
+    description: field('description'),
+    procedure: field('procedure'),
+    triggers: splitList(field('triggers')),
+    tags: splitList(field('tags')),
+    requirements: buildAgentWorkspaceRequirements(field),
+    enabled: isAffirmative(field('enabled')),
+    source: 'user',
+    provenance: 'Workspace',
+  });
+  finish('skill', created.id, created.name, 'Created');
+}
+
+function submitRoutineEditor(
+  shellPaths: ShellPathService,
+  editor: AgentWorkspaceLocalEditor,
+  field: (id: string) => string,
+  finish: AgentWorkspaceLocalEditorSubmissionCallbacks['finishLocalEditor'],
+): void {
+  const registry = AgentRoutineRegistry.fromShellPaths(shellPaths);
+  if (editor.mode === 'update' && editor.recordId) {
+    const updated = registry.update(editor.recordId, {
+      name: field('name'),
+      description: field('description'),
+      steps: field('steps'),
+      triggers: splitList(field('triggers')),
+      tags: splitList(field('tags')),
+      requirements: buildAgentWorkspaceRequirements(field),
+      provenance: 'Workspace',
+    });
+    registry.setEnabled(updated.id, isAffirmative(field('enabled')));
+    finish('routine', updated.id, updated.name, 'Updated');
+    return;
+  }
+  const created = registry.create({
+    name: field('name'),
+    description: field('description'),
+    steps: field('steps'),
+    triggers: splitList(field('triggers')),
+    tags: splitList(field('tags')),
+    requirements: buildAgentWorkspaceRequirements(field),
+    enabled: isAffirmative(field('enabled')),
+    source: 'user',
+    provenance: 'Workspace',
+  });
+  finish('routine', created.id, created.name, 'Created');
+}

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

@@ -40,6 +40,9 @@ export function searchAgentWorkspaceActions(
         action.command ?? '',
         action.editorKind ?? '',
         action.targetCategoryId ?? '',
+        action.modelPickerFlow ?? '',
+        action.modelPickerTarget ?? '',
+        action.settingsTarget ?? '',
         action.localOperation ?? '',
         action.safety,
       ].join(' ').toLowerCase();
@@ -80,6 +83,9 @@ function scoreActionSearchResult(
   score += scoreField(action.editorKind, terms, exactQuery, 85, 26);
   score += scoreField(action.command, terms, exactQuery, 75, 22);
   score += scoreField(action.label, terms, exactQuery, 65, 18);
+  score += scoreField(action.modelPickerTarget, terms, exactQuery, 58, 18);
+  score += scoreField(action.settingsTarget, terms, exactQuery, 58, 18);
+  score += scoreField(action.modelPickerFlow, terms, exactQuery, 54, 16);
   score += scoreField(action.localOperation, terms, exactQuery, 50, 16);
   score += scoreField(action.targetCategoryId, terms, exactQuery, 40, 12);
   score += scoreField(action.detail, terms, exactQuery, 24, 6);

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

@@ -0,0 +1,314 @@
+import { existsSync, readFileSync } from 'node:fs';
+import type { ConfigKey, ConfigSetting } from '@pellux/goodvibes-sdk/platform/config';
+import { setHarnessSetting } from '../agent/harness-control.ts';
+import { isExternalHostOwnedSettingKey } from '../config/agent-settings-policy.ts';
+import { buildAgentWorkspaceRuntimeSnapshot } from './agent-workspace-snapshot.ts';
+import type { CommandContext } from './command-registry.ts';
+import type {
+  AgentWorkspaceAction,
+  AgentWorkspaceActionResult,
+  AgentWorkspaceLocalEditor,
+  AgentWorkspaceRuntimeSnapshot,
+} from './agent-workspace-types.ts';
+
+const GOODVIBES_TUI_SURFACE_ROOT = 'tui';
+
+const TUI_IMPORTABLE_SETTING_PREFIXES = [
+  'display.',
+  'provider.',
+  'behavior.',
+  'storage.',
+  'permissions.',
+  'ui.',
+  'tts.',
+  'surfaces.',
+  'helper.',
+  'tools.',
+  'release.',
+  'automation.',
+] as const;
+
+type SettingActionEffect =
+  | {
+    readonly kind: 'result';
+    readonly status: string;
+    readonly result: AgentWorkspaceActionResult;
+  }
+  | {
+    readonly kind: 'apply';
+    readonly setting: ConfigSetting;
+    readonly value: unknown;
+  }
+  | {
+    readonly kind: 'editor';
+    readonly editor: AgentWorkspaceLocalEditor;
+    readonly status: string;
+    readonly result: AgentWorkspaceActionResult;
+  };
+
+export interface SettingMutationOutcome {
+  readonly status: string;
+  readonly result: AgentWorkspaceActionResult;
+}
+
+export interface TuiSettingsImportOutcome extends SettingMutationOutcome {
+  readonly runtimeSnapshot: AgentWorkspaceRuntimeSnapshot | null;
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+
+function readJsonRecord(path: string): Record<string, unknown> | null {
+  if (!existsSync(path)) return null;
+  const parsed = JSON.parse(readFileSync(path, 'utf-8')) as unknown;
+  return isRecord(parsed) ? parsed : null;
+}
+
+function readNestedSettingValue(record: Record<string, unknown>, key: string): unknown {
+  let cursor: unknown = record;
+  for (const part of key.split('.')) {
+    if (!isRecord(cursor) || !(part in cursor)) return undefined;
+    cursor = cursor[part];
+  }
+  return cursor;
+}
+
+function canImportTuiSetting(key: string): boolean {
+  return !isExternalHostOwnedSettingKey(key)
+    && TUI_IMPORTABLE_SETTING_PREFIXES.some((prefix) => key.startsWith(prefix));
+}
+
+function valuesMatch(left: unknown, right: unknown): boolean {
+  return JSON.stringify(left) === JSON.stringify(right);
+}
+
+export function agentWorkspaceSettingSchema(context: CommandContext | null, key: string): ConfigSetting | null {
+  return context?.platform?.configManager
+    ?.getSchema()
+    .find((setting) => setting.key === key) ?? null;
+}
+
+export function isAgentWorkspaceActionVisible(context: CommandContext | null, action: AgentWorkspaceAction): boolean {
+  const key = action.visibleWhenSettingKey?.trim();
+  if (!key) return true;
+  const configManager = context?.platform?.configManager;
+  if (!configManager) return false;
+  return configManager.get(key as ConfigKey) === action.visibleWhenSettingValue;
+}
+
+export function buildAgentWorkspaceSettingActionEffect(
+  context: CommandContext | null,
+  action: AgentWorkspaceAction,
+): SettingActionEffect {
+  const settingKey = action.settingKey?.trim();
+  const configManager = context?.platform?.configManager;
+  if (!settingKey || !configManager) {
+    return {
+      kind: 'result',
+      status: 'Setting is unavailable in this runtime.',
+      result: {
+        kind: 'error',
+        title: 'Setting unavailable',
+        detail: action.detail,
+        safety: action.safety,
+      },
+    };
+  }
+  const setting = agentWorkspaceSettingSchema(context, settingKey);
+  if (!setting) {
+    return {
+      kind: 'result',
+      status: `Unknown setting: ${settingKey}`,
+      result: {
+        kind: 'error',
+        title: 'Unknown setting',
+        detail: `No Agent setting exists for ${settingKey}.`,
+        safety: action.safety,
+      },
+    };
+  }
+
+  if (action.settingValueHint !== undefined) {
+    return { kind: 'apply', setting, value: action.settingValueHint };
+  }
+
+  const currentValue = configManager.get(setting.key as ConfigKey);
+  if (setting.type === 'boolean') {
+    return { kind: 'apply', setting, value: !Boolean(currentValue) };
+  }
+  if (setting.type === 'enum' && setting.enumValues && setting.enumValues.length > 0) {
+    const currentIndex = Math.max(0, setting.enumValues.indexOf(String(currentValue)));
+    return { kind: 'apply', setting, value: setting.enumValues[(currentIndex + 1) % setting.enumValues.length]! };
+  }
+
+  return {
+    kind: 'editor',
+    editor: createSettingEditor(setting, String(currentValue ?? ''), action),
+    status: `Editing ${setting.key}.`,
+    result: {
+      kind: 'guidance',
+      title: `Edit ${setting.key}`,
+      detail: setting.description,
+      safety: action.safety,
+    },
+  };
+}
+
+export async function applyAgentWorkspaceSettingValue(
+  context: CommandContext | null,
+  setting: ConfigSetting,
+  value: unknown,
+): Promise<SettingMutationOutcome> {
+  const configManager = context?.platform?.configManager;
+  if (!configManager) {
+    return {
+      status: 'Setting is unavailable in this runtime.',
+      result: {
+        kind: 'error',
+        title: `${setting.key} update failed`,
+        detail: 'The Agent workspace has no config manager for this runtime.',
+        safety: 'safe',
+      },
+    };
+  }
+  try {
+    const result = await setHarnessSetting(configManager, context?.platform?.secretsManager, setting.key, value);
+    return {
+      status: `${result.key} set.`,
+      result: {
+        kind: 'refreshed',
+        title: `${result.key} updated`,
+        detail: `Current value: ${String(result.current)}`,
+        safety: 'safe',
+      },
+    };
+  } catch (error) {
+    const detail = error instanceof Error ? error.message : String(error);
+    return {
+      status: detail,
+      result: {
+        kind: 'error',
+        title: `${setting.key} update failed`,
+        detail,
+        safety: 'safe',
+      },
+    };
+  }
+}
+
+export async function importAgentWorkspaceTuiSettings(context: CommandContext | null): Promise<TuiSettingsImportOutcome> {
+  const shellPaths = context?.workspace?.shellPaths;
+  const configManager = context?.platform?.configManager;
+  if (!shellPaths || !configManager) {
+    return {
+      status: 'GoodVibes TUI settings import is unavailable in this runtime.',
+      runtimeSnapshot: null,
+      result: {
+        kind: 'error',
+        title: 'Import unavailable',
+        detail: 'The workspace cannot locate shell paths or the Agent config manager.',
+        safety: 'safe',
+      },
+    };
+  }
+
+  const sources = [
+    { label: 'user', path: shellPaths.resolveUserPath(GOODVIBES_TUI_SURFACE_ROOT, 'settings.json') },
+    { label: 'project', path: shellPaths.resolveProjectPath(GOODVIBES_TUI_SURFACE_ROOT, 'settings.json') },
+  ];
+  const values = new Map<string, { readonly value: unknown; readonly source: string }>();
+  const parseErrors: string[] = [];
+  for (const source of sources) {
+    try {
+      const record = readJsonRecord(source.path);
+      if (!record) continue;
+      for (const setting of configManager.getSchema()) {
+        if (!canImportTuiSetting(setting.key)) continue;
+        const value = readNestedSettingValue(record, setting.key);
+        if (value !== undefined) values.set(setting.key, { value, source: source.label });
+      }
+    } catch (error) {
+      parseErrors.push(`${source.label}: ${error instanceof Error ? error.message : String(error)}`);
+    }
+  }
+
+  if (values.size === 0) {
+    const detail = parseErrors.length > 0
+      ? `No importable settings found. ${parseErrors.join('; ')}`
+      : 'No GoodVibes TUI settings file with importable Agent-owned settings was found.';
+    return {
+      status: 'No GoodVibes TUI settings imported.',
+      runtimeSnapshot: null,
+      result: {
+        kind: parseErrors.length > 0 ? 'error' : 'guidance',
+        title: 'Nothing imported',
+        detail,
+        safety: 'safe',
+      },
+    };
+  }
+
+  const imported: string[] = [];
+  const unchanged: string[] = [];
+  const skipped: string[] = [];
+  for (const [key, entry] of values) {
+    const setting = agentWorkspaceSettingSchema(context, key);
+    if (!setting) continue;
+    if (valuesMatch(configManager.get(setting.key as ConfigKey), entry.value)) {
+      unchanged.push(setting.key);
+      continue;
+    }
+    try {
+      await setHarnessSetting(configManager, context?.platform?.secretsManager, setting.key, entry.value);
+      imported.push(`${setting.key} (${entry.source})`);
+    } catch (error) {
+      skipped.push(`${setting.key}: ${error instanceof Error ? error.message : String(error)}`);
+    }
+  }
+
+  return {
+    status: imported.length > 0 ? `Imported ${imported.length} GoodVibes TUI setting(s).` : 'No GoodVibes TUI settings changed.',
+    runtimeSnapshot: context ? buildAgentWorkspaceRuntimeSnapshot(context) : null,
+    result: {
+      kind: skipped.length > 0 && imported.length === 0 ? 'error' : imported.length > 0 ? 'refreshed' : 'guidance',
+      title: imported.length > 0 ? 'GoodVibes TUI settings imported' : 'No settings changed',
+      detail: [
+        imported.length > 0 ? `Imported: ${imported.slice(0, 10).join(', ')}${imported.length > 10 ? `, +${imported.length - 10} more` : ''}.` : '',
+        unchanged.length > 0 ? `${unchanged.length} setting(s) already matched.` : '',
+        skipped.length > 0 ? `Skipped: ${skipped.slice(0, 5).join('; ')}${skipped.length > 5 ? `; +${skipped.length - 5} more` : ''}.` : '',
+        parseErrors.length > 0 ? `Parse issues: ${parseErrors.join('; ')}.` : '',
+      ].filter((line) => line.length > 0).join(' '),
+      safety: 'safe',
+    },
+  };
+}
+
+function createSettingEditor(setting: ConfigSetting, currentValue: string, action: AgentWorkspaceAction): AgentWorkspaceLocalEditor {
+  const valueHint = setting.type === 'number'
+    ? 'Enter a number.'
+    : setting.type === 'string'
+      ? 'Enter a value. Leave empty to clear it.'
+      : setting.enumValues
+        ? `Allowed values: ${setting.enumValues.join(', ')}.`
+        : action.detail;
+  return {
+    kind: 'setting-set',
+    mode: 'update',
+    recordId: setting.key,
+    title: `Set ${setting.key}`,
+    selectedFieldIndex: 0,
+    message: action.detail,
+    fields: [
+      {
+        id: 'value',
+        label: setting.key,
+        value: currentValue,
+        required: false,
+        multiline: false,
+        hint: action.settingValueHint ?? valueHint,
+        redact: /(?:secret|token|password|api[-_.]?key|signing)/i.test(setting.key),
+      },
+    ],
+  };
+}

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

@@ -14,6 +14,9 @@ export interface AgentWorkspaceSetupChecklistInput {
   readonly provider: string;
   readonly model: string;
   readonly runtimeBaseUrl: string;
+  readonly activeSubscriptionCount: number;
+  readonly pendingSubscriptionCount: number;
+  readonly availableSubscriptionProviderCount: number;
   readonly sessionMemoryCount: number;
   readonly localMemoryCount: number;
   readonly localMemoryReviewQueueCount: number;
@@ -69,6 +72,23 @@ export function buildAgentWorkspaceSetupChecklist(input: AgentWorkspaceSetupChec
         : 'Choose a provider and model before relying on assistant turns.',
       command: 'Setup -> Provider and model',
     },
+    {
+      id: 'subscriptions',
+      label: 'Provider subscriptions',
+      status: input.activeSubscriptionCount > 0
+        ? 'ready'
+        : input.pendingSubscriptionCount > 0
+          ? 'recommended'
+          : input.availableSubscriptionProviderCount > 0 ? 'recommended' : 'optional',
+      detail: input.activeSubscriptionCount > 0
+        ? `${input.activeSubscriptionCount} provider subscription session(s) are active.`
+        : input.pendingSubscriptionCount > 0
+          ? `${input.pendingSubscriptionCount} provider subscription login(s) are pending completion.`
+          : input.availableSubscriptionProviderCount > 0
+            ? `${input.availableSubscriptionProviderCount} subscription-capable provider(s) are available. Start login if you want subscription routing.`
+            : 'No subscription-capable providers are available yet. Use API keys or add an OAuth provider service.',
+      command: 'Start -> Start subscription login',
+    },
     {
       id: 'agent-knowledge',
       label: 'Agent Knowledge',