@pellux/goodvibes-agent 1.1.2 → 1.1.4

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-types.ts

@@ -10,6 +10,14 @@ export type AgentWorkspaceFocusPane = 'categories' | 'actions';
 export const AGENT_WORKSPACE_CATEGORY_IDS = [
   'home',
   'setup',
+  'account-model',
+  'assistant-behavior',
+  'tools-permissions',
+  'onboarding-display',
+  'onboarding-channels',
+  'onboarding-voice-media',
+  'onboarding-context',
+  'onboarding-verify',
   'research',
   'artifacts',
   'conversation',
@@ -32,7 +40,7 @@ export const AGENT_WORKSPACE_CATEGORY_IDS = [
 
 export type AgentWorkspaceCategoryId = (typeof AGENT_WORKSPACE_CATEGORY_IDS)[number];
 
-export type AgentWorkspaceActionKind = 'command' | 'guidance' | 'workspace' | 'editor' | 'local-selection' | 'local-operation' | 'onboarding-complete';
+export type AgentWorkspaceActionKind = 'command' | 'guidance' | 'workspace' | 'editor' | 'setting' | 'settings-import' | 'local-selection' | 'local-operation' | 'onboarding-complete';
 
 export type AgentWorkspaceLocalEditorKind = 'memory' | 'note' | 'persona' | 'skill' | 'routine' | 'profile';
 
@@ -178,6 +186,7 @@ export type AgentWorkspaceEditorKind =
   | 'schedule-receipt'
   | 'mode-preset'
   | 'mode-domain'
+  | 'setting-set'
   | 'model-pin'
   | 'model-unpin'
   | 'delegate-task'
@@ -247,6 +256,10 @@ export interface AgentWorkspaceAction {
   readonly command?: string;
   readonly targetCategoryId?: AgentWorkspaceCategoryId;
   readonly editorKind?: AgentWorkspaceEditorKind;
+  readonly settingKey?: string;
+  readonly settingValueHint?: string;
+  readonly visibleWhenSettingKey?: string;
+  readonly visibleWhenSettingValue?: string | boolean | number;
   readonly localKind?: AgentWorkspaceLocalEditorKind;
   readonly selectionDelta?: number;
   readonly localOperation?: AgentWorkspaceLocalOperation;

package/src/input/agent-workspace.ts

@@ -1,5 +1,6 @@
 import type { MemoryApi } from '@pellux/goodvibes-sdk/platform/knowledge';
 import type { MemoryRecord } from '@pellux/goodvibes-sdk/platform/state';
+import type { ConfigSetting } from '@pellux/goodvibes-sdk/platform/config';
 import type { ShellPathService } from '@/runtime/index.ts';
 import type { CommandContext } from './command-registry.ts';
 import { AgentNoteRegistry } from '../agent/note-registry.ts';
@@ -18,6 +19,7 @@ import { deleteAgentWorkspaceMemoryEditor, submitAgentWorkspaceMemoryEditor } fr
 import { jumpAgentWorkspaceSelection, moveAgentWorkspaceSelection, selectAgentWorkspaceCategory } from './agent-workspace-navigation.ts';
 import { buildAgentWorkspaceRequirements } from './agent-workspace-requirements.ts';
 import { appendAgentWorkspaceActionSearchText, backspaceAgentWorkspaceActionSearch, beginAgentWorkspaceActionSearch, clearAgentWorkspaceActionSearch, commitAgentWorkspaceActionSearchSelection, searchAgentWorkspaceActions } from './agent-workspace-search.ts';
+import { agentWorkspaceSettingSchema, applyAgentWorkspaceSettingValue, buildAgentWorkspaceSettingActionEffect, importAgentWorkspaceTuiSettings, isAgentWorkspaceActionVisible } from './agent-workspace-settings.ts';
 import { buildAgentWorkspaceRuntimeSnapshot } from './agent-workspace-snapshot.ts';
 import type { AgentWorkspaceAction, AgentWorkspaceActionResult, AgentWorkspaceActionSearchResult, AgentWorkspaceCategory, AgentWorkspaceCommandDispatcher, AgentWorkspaceEditorField, AgentWorkspaceFocusPane, AgentWorkspaceLocalEditor, AgentWorkspaceLocalEditorKind, AgentWorkspaceLocalLibraryItem, AgentWorkspaceLocalOperation, AgentWorkspacePromptDispatcher, AgentWorkspaceRuntimeSnapshot } from './agent-workspace-types.ts';
 import { writeOnboardingCheckMarker, writeOnboardingCompletionMarker } from '../runtime/onboarding/index.ts';
@@ -39,14 +41,7 @@ export class AgentWorkspace {
   public localEditor: AgentWorkspaceLocalEditor | null = null;
   public actionSearchActive = false;
   public actionSearchQuery = '';
-  public readonly selectedLibraryItemIndexes: AgentWorkspaceLocalSelectionIndexes = {
-    memory: 0,
-    note: 0,
-    persona: 0,
-    skill: 0,
-    routine: 0,
-    profile: 0,
-  };
+  public readonly selectedLibraryItemIndexes: AgentWorkspaceLocalSelectionIndexes = { memory: 0, note: 0, persona: 0, skill: 0, routine: 0, profile: 0 };
   private context: CommandContext | null = null;
   private dispatchCommand: AgentWorkspaceCommandDispatcher | null = null;
   private dispatchPrompt: AgentWorkspacePromptDispatcher | null = null;
@@ -63,7 +58,10 @@ export class AgentWorkspace {
     this.localEditor = null;
     this.actionSearchActive = false;
     this.actionSearchQuery = '';
-    if (categoryId && !this.selectCategory(categoryId)) {
+    if (!categoryId) {
+      this.selectedCategoryIndex = 0;
+      this.selectedActionIndex = 0;
+    } else if (!this.selectCategory(categoryId)) {
       const normalized = categoryId.trim();
       this.status = `Unknown Agent workspace area: ${normalized}`;
       this.lastActionResult = {
@@ -98,7 +96,7 @@ export class AgentWorkspace {
 
   get actions(): readonly AgentWorkspaceAction[] {
     if (this.actionSearchActive) return this.actionSearchResults.map((result) => result.action);
-    return this.selectedCategory.actions;
+    return this.selectedCategory.actions.filter((action) => isAgentWorkspaceActionVisible(this.context, action));
   }
 
   get selectedAction(): AgentWorkspaceAction | null {
@@ -111,7 +109,12 @@ export class AgentWorkspace {
   }
 
   get actionSearchResults(): readonly AgentWorkspaceActionSearchResult[] {
-    return this.actionSearchActive ? searchAgentWorkspaceActions(this.categories, this.actionSearchQuery) : [];
+    if (!this.actionSearchActive) return [];
+    const categories = this.categories.map((category) => ({
+      ...category,
+      actions: category.actions.filter((action) => isAgentWorkspaceActionVisible(this.context, action)),
+    }));
+    return searchAgentWorkspaceActions(categories, this.actionSearchQuery);
   }
 
   get selectedActionSearchResult(): AgentWorkspaceActionSearchResult | null {
@@ -178,11 +181,7 @@ export class AgentWorkspace {
     }
     this.runtimeSnapshot = buildAgentWorkspaceRuntimeSnapshot(this.context);
     this.status = 'Runtime context refreshed.';
-    this.lastActionResult = {
-      kind: 'refreshed',
-      title: 'Runtime context refreshed',
-      detail: 'Provider, model, session, local memory, runtime endpoint, and Agent knowledge route posture were re-read from the live command context.',
-    };
+    this.lastActionResult = { kind: 'refreshed', title: 'Runtime context refreshed', detail: 'Provider, model, session, local memory, runtime endpoint, and Agent knowledge route posture were re-read from the live command context.' };
   }
 
   cancelLocalEditor(): void {
@@ -321,32 +320,37 @@ export class AgentWorkspace {
     }
 
     try {
-      const marker = {
-        scope: 'user',
-        source: 'wizard',
-        mode: 'new',
-        workspaceRoot: shellPaths.workingDirectory,
-      } as const;
+      const marker = { scope: 'user', source: 'wizard', mode: 'new', workspaceRoot: shellPaths.workingDirectory } as const;
       writeOnboardingCheckMarker(shellPaths, marker);
       writeOnboardingCompletionMarker(shellPaths, marker);
       this.status = 'Onboarding applied and closed.';
-      this.lastActionResult = {
-        kind: 'refreshed',
-        title: 'Onboarding complete',
-        detail: 'Saved the user onboarding completion marker. Future normal launches start in the main conversation.',
-        safety: 'safe',
-      };
+      this.lastActionResult = { kind: 'refreshed', title: 'Onboarding complete', detail: 'Saved the user onboarding completion marker. Future normal launches start in the main conversation.', safety: 'safe' };
       if (!this.context?.dismissAgentWorkspace?.()) this.close();
     } catch (error) {
       const detail = error instanceof Error ? error.message : String(error);
       this.status = 'Onboarding completion failed.';
-      this.lastActionResult = {
-        kind: 'error',
-        title: 'Onboarding completion failed',
-        detail,
-        safety: 'safe',
-      };
+      this.lastActionResult = { kind: 'error', title: 'Onboarding completion failed', detail, safety: 'safe' };
+    }
+  }
+
+  applySettingAction(action: AgentWorkspaceAction, requestRender?: () => void): void {
+    const effect = buildAgentWorkspaceSettingActionEffect(this.context, action);
+    if (effect.kind === 'result') {
+      this.status = effect.status;
+      this.lastActionResult = effect.result;
+      return;
     }
+    if (effect.kind === 'editor') {
+      this.localEditor = effect.editor;
+      this.status = effect.status;
+      this.lastActionResult = effect.result;
+      return;
+    }
+    void this.applySettingValue(effect.setting, effect.value, requestRender);
+  }
+
+  importTuiSettings(requestRender?: () => void): void {
+    void this.importTuiSettingsAsync(requestRender);
   }
 
   private selectedItemForOperation(operation: AgentWorkspaceLocalOperation): AgentWorkspaceLocalLibraryItem | null {
@@ -357,6 +361,24 @@ export class AgentWorkspace {
     return this.selectedLocalLibraryItem('routine');
   }
 
+  private async applySettingValue(setting: ConfigSetting, value: unknown, requestRender?: () => void): Promise<void> {
+    const outcome = await applyAgentWorkspaceSettingValue(this.context, setting, value);
+    this.runtimeSnapshot = this.context ? buildAgentWorkspaceRuntimeSnapshot(this.context) : this.runtimeSnapshot;
+    this.clampSelection();
+    this.status = outcome.status;
+    this.lastActionResult = outcome.result;
+    requestRender?.();
+  }
+
+  private async importTuiSettingsAsync(requestRender?: () => void): Promise<void> {
+    const outcome = await importAgentWorkspaceTuiSettings(this.context);
+    this.runtimeSnapshot = outcome.runtimeSnapshot ?? this.runtimeSnapshot;
+    this.clampSelection();
+    this.status = outcome.status;
+    this.lastActionResult = outcome.result;
+    requestRender?.();
+  }
+
   private memoryApi(): MemoryApi {
     const memory = this.context?.clients?.agentKnowledgeApi?.memory;
     if (!memory) throw new Error('Agent Memory API is unavailable; refusing default knowledge or non-Agent fallback.');
@@ -429,6 +451,19 @@ export class AgentWorkspace {
       requestRender?.();
       return;
     }
+    if (editor.kind === 'setting-set') {
+      const setting = editor.recordId ? agentWorkspaceSettingSchema(this.context, editor.recordId) : null;
+      if (!setting) {
+        this.localEditor = { ...editor, message: 'Unknown setting; cannot save.' };
+        this.status = 'Unknown setting; cannot save.';
+        requestRender?.();
+        return;
+      }
+      const value = this.editorField('value');
+      this.localEditor = null;
+      void this.applySettingValue(setting, value, requestRender);
+      return;
+    }
     if (editor.kind === 'memory') {
       if (editor.mode === 'delete') {
         try {

package/src/renderer/agent-workspace.ts

@@ -17,7 +17,7 @@ import {
   WORKSPACE_PALETTE as PALETTE,
   type WorkspaceRow,
 } from './fullscreen-workspace.ts';
-import { actionResultColor, safetyColor, setupStatusColor, type AgentWorkspaceContextLine as ContextLine } from './agent-workspace-style.ts';
+import { actionResultColor, setupStatusColor, type AgentWorkspaceContextLine as ContextLine } from './agent-workspace-style.ts';
 
 function buildLeftRows(workspace: AgentWorkspace, height: number): WorkspaceRow[] {
   const rows: WorkspaceRow[] = [];
@@ -57,6 +57,8 @@ function buildLeftRows(workspace: AgentWorkspace, height: number): WorkspaceRow[
 function actionCommand(action: AgentWorkspaceAction): string {
   if (action.kind === 'workspace') return action.targetCategoryId ? `open ${action.targetCategoryId}` : '(workspace)';
   if (action.kind === 'editor') return action.editorKind ? `edit ${action.editorKind}` : '(editor)';
+  if (action.kind === 'setting') return action.settingKey ? `set ${action.settingKey}` : 'set setting';
+  if (action.kind === 'settings-import') return 'import GoodVibes settings';
   if (action.kind === 'local-selection') return action.selectionDelta && action.selectionDelta < 0 ? 'select previous' : 'select next';
   if (action.kind === 'local-operation') return action.localOperation ?? '(local action)';
   return action.command ?? '(guidance)';
@@ -91,8 +93,8 @@ function compactText(text: string, maxWidth = 104): string {
 
 function actionMetaLine(action: AgentWorkspaceAction): ContextLine {
   return {
-    text: `${actionCommand(action)}; ${action.safety}`,
-    fg: action.kind === 'command' ? PALETTE.info : safetyColor(action),
+    text: `Does: ${actionCommand(action)}`,
+    fg: action.safety === 'blocked' ? PALETTE.warn : action.kind === 'command' ? PALETTE.info : PALETTE.muted,
   };
 }
 
@@ -116,7 +118,7 @@ function setupOverviewLines(snapshot: AgentWorkspaceRuntimeSnapshot): ContextLin
   const counts = setupCounts(snapshot);
   const nextItems = setupAttentionItems(snapshot, 3);
   const lines: ContextLine[] = [
-    { text: 'Setup Overview', fg: PALETTE.title, bold: true },
+    { text: 'Onboarding', fg: PALETTE.title, bold: true },
     { text: `${counts.ready}/${snapshot.setupChecklist.length} ready; ${counts.recommended} recommended; ${counts.optional} optional; ${counts.blocked} blocked.`, fg: counts.blocked > 0 ? PALETTE.warn : PALETTE.info },
     { text: `Chat: ${snapshot.provider} / ${snapshot.modelDisplayName}.`, fg: PALETTE.info },
     { text: `Local: ${snapshot.localPersonaCount} personas, ${snapshot.localSkillCount} skills, ${snapshot.localRoutineCount} routines, ${snapshot.localMemoryCount} memories.`, fg: PALETTE.info },
@@ -309,7 +311,7 @@ function snapshotLines(workspace: AgentWorkspace, category: AgentWorkspaceCatego
       companionAccessLine(snapshot),
       { text: `Channels: ${readyCount}/${snapshot.channels.length} ready; ${enabledCount} enabled; ${configuredDefaults} target(s).`, fg: PALETTE.info },
       { text: `Next: ${nextAttentionChannel ? `${nextAttentionChannel.label} - ${compactText(nextAttentionChannel.nextStep)}` : 'All enabled channels ready.'}`, fg: nextAttentionChannel ? PALETTE.warn : PALETTE.good },
-      { text: 'Safety: secrets hidden; sends require explicit action.', fg: PALETTE.warn },
+      { text: 'Secrets hidden; sends require explicit action.', fg: PALETTE.warn },
     );
   } else if (category.id === 'knowledge') {
     base.push(
@@ -536,9 +538,8 @@ function buildEditorFieldRows(editor: AgentWorkspaceLocalEditor, index: number,
 function buildActionRows(workspace: AgentWorkspace, width: number, height: number): WorkspaceRow[] {
   if (workspace.localEditor) return buildEditorRows(workspace.localEditor, width, height);
   const rows: WorkspaceRow[] = [];
-  const labelWidth = Math.min(28, Math.max(16, Math.floor(width * 0.30)));
-  const safetyWidth = 10;
-  const commandWidth = Math.max(10, width - labelWidth - safetyWidth - 9);
+  const labelWidth = Math.min(34, Math.max(18, Math.floor(width * 0.38)));
+  const commandWidth = Math.max(10, width - labelWidth - 6);
   if (workspace.actionSearchActive) {
     rows.push({
       text: `  Search: ${workspace.actionSearchQuery || '(type to filter actions)'}`,
@@ -547,7 +548,7 @@ function buildActionRows(workspace: AgentWorkspace, width: number, height: numbe
     });
   }
   rows.push({
-    text: `  ${padDisplay(workspace.actionSearchActive ? 'Result' : 'Action', labelWidth)}  ${padDisplay('Safety', safetyWidth)}  ${padDisplay('Command', commandWidth)}`,
+    text: `  ${padDisplay(workspace.actionSearchActive ? 'Result' : 'Action', labelWidth)}  ${padDisplay('Does', commandWidth)}`,
     fg: PALETTE.muted,
     bold: true,
   });
@@ -564,9 +565,9 @@ function buildActionRows(workspace: AgentWorkspace, width: number, height: numbe
     const label = searchResult ? `${searchResult.category.label} / ${action.label}` : action.label;
     const marker = selected ? GLYPHS.navigation.selected : ' ';
     rows.push({
-      text: `${marker} ${padDisplay(label, labelWidth)}  ${padDisplay(action.safety, safetyWidth)}  ${padDisplay(actionCommand(action), commandWidth)}`,
+      text: `${marker} ${padDisplay(label, labelWidth)}  ${padDisplay(actionCommand(action), commandWidth)}`,
       selected: selected && workspace.focusPane === 'actions',
-      fg: safetyColor(action),
+      fg: action.safety === 'blocked' ? PALETTE.warn : selected ? PALETTE.text : PALETTE.info,
       bold: selected,
     });
   }
@@ -620,7 +621,7 @@ export function renderAgentWorkspace(workspace: AgentWorkspace, width: number, h
     leftHeader: 'Operator Areas',
     mainHeader: workspace.actionSearchActive
       ? `Search actions · ${workspace.actions.length} result(s)`
-      : `${category.label} · ${category.actions.length} action(s)`,
+      : `${category.label} · ${workspace.actions.length} action(s)`,
     leftRows: buildLeftRows(workspace, metrics.bodyRows),
     contextRows: buildContextRows(workspace, category, action, metrics.contextWidth),
     controlRows: buildActionRows(workspace, metrics.contextWidth, metrics.controlRows),

package/src/tools/agent-harness-ui-surface-metadata.ts

@@ -327,7 +327,7 @@ const UI_SURFACES: readonly UiSurfaceDefinition[] = [
     kind: 'picker',
     summary: 'Reasoning-effort selector for models that expose effort levels.',
     command: '/effort',
-    preferredModelRoute: `Use ${agentHarnessModes('settings', 'get_setting', 'set_setting')} for provider.reasoningEffort when a concrete level is known, or mode:"run_workspace_action" setup-effort with confirmation.`,
+    preferredModelRoute: `Use ${agentHarnessModes('settings', 'get_setting', 'set_setting')} for provider.reasoningEffort when a concrete level is known, or mode:"run_workspace_action" setup-reasoning-effort with confirmation.`,
     available: (context) => typeof context.openReasoningEffortPicker === 'function',
     open: (context) => {
       const surface = findSurfaceById('reasoning-effort-picker')!;

package/src/tools/agent-harness-workspace-actions.ts

@@ -55,7 +55,7 @@ function readString(value: unknown): string {
 function readLimit(value: unknown, fallback: number): number {
   const parsed = typeof value === 'string' && value.trim() ? Number(value) : value;
   if (typeof parsed !== 'number' || !Number.isFinite(parsed)) return fallback;
-  return Math.max(1, Math.min(500, Math.trunc(parsed)));
+  return Math.max(1, Math.min(1000, Math.trunc(parsed)));
 }
 
 function readFieldMap(value: unknown): Readonly<Record<string, string>> {
@@ -256,7 +256,7 @@ export function listWorkspaceActions(
 ): readonly Record<string, unknown>[] {
   const query = readString(args.query);
   const categoryId = readString(args.categoryId || args.category);
-  const limit = readLimit(args.limit, 500);
+  const limit = readLimit(args.limit, 1000);
   const includeEditor = args.includeParameters === true;
   const editorContext = includeEditor ? buildWorkspaceEditorContext(context, args) : null;
   const source = query

package/src/version.ts

@@ -6,7 +6,7 @@ import { join } from 'node:path';
 // The prebuild script updates the fallback value before compilation.
 // Uses import.meta.dir (Bun) to locate package.json relative to this file,
 // which is correct regardless of the process working directory.
-let _version = '1.1.2';
+let _version = '1.1.4';
 try {
   const pkg = JSON.parse(readFileSync(join(import.meta.dir, '..', 'package.json'), 'utf-8')) as {
     readonly version?: unknown;