@zergai/ztc 0.2.6-dev.36102446685 → 0.3.0-beta.1

package/dist/agent/commands/settings.js

@@ -1,4 +1,11 @@
+import { accountsCommand } from './accounts.js';
+import { authCommand } from './auth.js';
+import { activeProfile, builtinProfileEmulation, listConfigProfiles } from '../../config/profiles.js';
+import { switchConfigProfile } from './config_profile_switch.js';
+import { keybindingsCommand } from './keybindings.js';
 import { DEFAULT_CONTEXT_PROGRESS_BAR } from '../../config.js';
+import { loadRouterCredentials } from '../../router_auth.js';
+import { CODEX_REASONING_EFFORTS } from '../../config/types.js';
 import { customPaneOptions, storedCustomPaneOptions, withCustomPaneOptions, } from '../../config/panes.js';
 import { getMcpServerStatuses } from '../../mcp/registry.js';
 import { hasUsableClaudeCodeCliAuth, isClaudeCliAvailable } from '../backends/claude_cli.js';
@@ -6,11 +13,14 @@ import { resolveModelForProviderChange } from './provider_model_defaults.js';
 import { normalizeProviderId } from '../backends/provider_ids.js';
 import { applyRuntimeModelSelection, getEffectiveModel } from './runtime_model.js';
 import { parseGoalTurnCap } from './goal.js';
+import { shutdownAndClearWorkflowRegistry } from '../../workflows/registry_handle.js';
+import { invalidateSkillsCache, preloadSkillsManifest } from '../../skills/registry.js';
 import { MIN_TOOL_OUTPUT_LINES, parseToolOutputLines, resolveMessageDisplaySettings, } from '../../config/message_display.js';
 import { DEFAULT_JEV_SETTINGS, MAX_AUTO_COMPACT_THRESHOLD, MAX_COMPACTION_TARGET_PERCENT, MIN_AUTO_COMPACT_THRESHOLD, MIN_COMPACTION_TARGET_PERCENT, MIN_CONTEXT_TOKEN_BUDGET, defaultTokenTrigger, maxCompactionTargetFor, minAutoCompactThresholdFor, parseCompactionTriggerMode, resolveAutoCompactThreshold, resolveCompactionTargetPercent, resolveCompactionTriggerMode, resolveCompactionSettings, resolveContextTokenBudget, tokenTriggerActive, MAX_JEV_KEEP_THRESHOLD, MAX_JEV_STATE_TOKENS, MIN_JEV_KEEP_THRESHOLD, MIN_JEV_PRESERVE_RECENT, MIN_JEV_STATE_TOKENS, parseAutoCompactThreshold, parseCompactionTargetPercent, parseContextTokenBudget, parseJevKeepThreshold, parseJevPreserveRecent, parseJevStateTokens, } from '../../config/compaction.js';
 import { MIN_MAX_ITERATIONS, parseMaxIterations } from '../../config/agent_limits.js';
 import { MAX_SFX_VOLUME, MIN_SFX_VOLUME, parseSfxPack, parseSfxVolume, resolveSfxPack, resolveSfxVolume, } from '../../config/sound.js';
 import { listPacks } from '../../audio/sfx.js';
+import { DEFAULT_SPINNER_VERBS, parseSpinnerVerbs } from '../../utils/spinner_verbs.js';
 import { MIN_API_RETRY_ATTEMPTS, MIN_API_RETRY_BASE_DELAY_MS, MIN_API_RETRY_TIMEOUT_MS, parseApiRetryAttempts, parseApiRetryBaseDelayMs, parseApiRetryTimeoutMs, resolveApiRetrySettings, } from '../../config/api_retry.js';
 import { STATUS_LINE_ITEMS, compactStatusLineVariants, normalizeStatusLineSeparator, parseStatusLineItems, replaceStatusLineSide, resolveStatusLineSettings, statusLineItemOptions, statusLineSettingsForStorage, } from '../../ui/status_line_config.js';
 import { BAR_COLOR_FIELDS, contextProgressBarConfig, normalizeBarColor, publishContextProgressBar, withBarColor, } from './context_progress_bar.js';
@@ -25,25 +35,6 @@ function describeStatusLineSide(statusLine, side) {
         .map(item => (overrides[item] ? `${item}:${overrides[item]}` : item))
         .join(', ');
 }
-/**
- * A row that only applies while another row holds one of these values. The
- * panel hides it otherwise, so a settings list shows what can be changed now
- * instead of knobs that do nothing.
- */
-function appliesWhen(name, ...accepted) {
-    return (value) => accepted.includes(value(name));
-}
-/** The Jev knobs configure the delete-only strategy that jev selects. */
-const jevSelected = appliesWhen('compactionMethod', 'jev');
-/** Each compaction trigger row describes the rule its own mode selects. */
-const percentTriggerSelected = appliesWhen('compactionTriggerMode', 'percent');
-const tokenTriggerSelected = appliesWhen('compactionTriggerMode', 'tokens');
-/** Field, separator, and color rows describe a line that must be shown first. */
-const statusLineShown = appliesWhen('statusLineEnabled', 'true');
-/** Volume and pack pick how a sound plays, so they need sound switched on. */
-const soundEnabled = appliesWhen('sfxEnabled', 'true');
-/** The progress-bar colors paint a bar that must be enabled first. */
-const progressBarShown = appliesWhen('contextProgressBarEnabled', 'true');
 /**
  * The status line offers the same field catalogue to both sides, so the panel
  * shows one checkbox per field with its subject group and description.
@@ -78,8 +69,66 @@ const PROVIDERS = [
     { value: 'kimi_code', label: 'Kimi Code', description: 'Kimi subscription via Kimi Code OAuth (device login)' },
     { value: 'openai_compatible', label: 'Custom Endpoint', description: 'Ollama, vLLM, etc.' },
 ];
+function toggleSetting(name, label, enabled, description) {
+    return {
+        name, label, value: String(enabled), type: 'select', description,
+        options: [{ value: 'true', label: 'on' }, { value: 'false', label: 'off' }],
+    };
+}
+function configuredSetting(ctx, name, label, value, description) {
+    const setting = {
+        name, label, value, type: 'text', description,
+        onActivate: () => {
+            ctx.settingsPanel?.closeSettingsPanel?.();
+            ctx.addMessage({ role: 'system', content: `${label}: ${setting.value}\n${description}` });
+        },
+    };
+    return setting;
+}
+function wholeCount(value, label, min = 1, max = Number.MAX_SAFE_INTEGER) {
+    const trimmed = value.trim();
+    const parsed = Number(trimmed);
+    if (!/^\d+$/.test(trimmed) || !Number.isSafeInteger(parsed) || parsed < min || parsed > max) {
+        throw new Error(`${label} must be a ${min === 0 ? 'non-negative' : 'positive'} whole number between ${min} and ${max}.`);
+    }
+    return parsed;
+}
+function stringArray(value, label) {
+    let parsed;
+    try {
+        parsed = JSON.parse(value);
+    }
+    catch {
+        throw new Error(`${label} must be a JSON array of strings.`);
+    }
+    if (!Array.isArray(parsed) || !parsed.every(item => typeof item === 'string' && item.trim() !== '')) {
+        throw new Error(`${label} must be a JSON array of strings.`);
+    }
+    return parsed;
+}
+function routerLoginOrigin(config, storedOrigin) {
+    const candidate = storedOrigin ?? config.zergProxyUrl;
+    if (!candidate)
+        return undefined;
+    try {
+        const url = new URL(candidate);
+        const loopback = ['localhost', '127.0.0.1', '[::1]'].includes(url.hostname);
+        return (url.protocol === 'https:' || (url.protocol === 'http:' && loopback))
+            && url.pathname === '/' && !url.username && !url.password && !url.search && !url.hash
+            ? url.origin : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+async function routerSessionIsCurrent() {
+    const credentials = await loadRouterCredentials().catch(() => null);
+    return credentials !== null && Date.parse(credentials.expiresAt) > Date.now();
+}
 export async function buildSettingsCategories(ctx) {
     const config = ctx.config.get();
+    const routerCredentials = await loadRouterCredentials().catch(() => null);
+    const routerSignedIn = routerCredentials !== null && Date.parse(routerCredentials.expiresAt) > Date.now();
     const provider = ctx.config.getProvider();
     const model = ctx.config.getModel?.() || config.model;
     const claudeCliInstalled = isClaudeCliAvailable();
@@ -118,10 +167,17 @@ export async function buildSettingsCategories(ctx) {
         modelOptions = models.slice(0, 20).map(m => ({ value: m, label: m }));
     }
     catch { /* fallback: no pre-fetched options, user can type manually */ }
-    return [
+    const sections = [
         {
             name: 'Config Scope',
             settings: [
+                {
+                    name: 'configProfile',
+                    label: 'Active config profile',
+                    value: activeProfile(),
+                    type: 'text',
+                    description: 'Open the profile picker. The current conversation stays in this session.',
+                },
                 {
                     name: 'configScope',
                     label: 'Write scope',
@@ -142,8 +198,28 @@ export async function buildSettingsCategories(ctx) {
                         { value: 'yes', label: 'Yes, clear local overrides' },
                     ],
                 },
+                {
+                    name: 'factoryReset',
+                    label: 'Factory reset settings',
+                    value: '',
+                    type: 'text',
+                    description: builtinProfileEmulation(activeProfile())
+                        ? 'Clear shared default settings, including stored API keys and account registrations, and ZRouter sign-in. Sessions and managed account directories stay on disk.'
+                        : 'Clear saved settings for this profile, including stored API keys and account registrations, and its ZRouter sign-in. Sessions and managed account directories stay on disk.',
+                },
             ],
         },
+        {
+            name: 'Accounts',
+            settings: [{
+                    name: 'manageAccounts',
+                    label: 'Manage accounts',
+                    value: 'Claude · Codex · Kimi',
+                    type: 'text',
+                    description: 'Switch signed-in accounts, check usage, or refresh a stale sign-in.',
+                    onActivate: () => { void accountsCommand.handler([], ctx); },
+                }],
+        },
         {
             name: 'Provider & Model',
             settings: [
@@ -165,6 +241,27 @@ export async function buildSettingsCategories(ctx) {
                     options: modelOptions.length > 0 ? modelOptions : undefined,
                     placeholder: 'e.g., claude-sonnet-4-6',
                 },
+                {
+                    name: 'maxTokens',
+                    label: 'Max tokens',
+                    value: config.maxTokens === undefined ? 'provider default' : String(config.maxTokens),
+                    type: 'text',
+                    placeholder: 'provider default',
+                    description: 'Maximum output tokens, including reasoning tokens. Enter a positive whole number, or "provider default" to clear the limit.',
+                },
+                {
+                    name: 'codexEffort', label: 'Default reasoning effort',
+                    value: config.codexEffort ?? 'provider default', type: 'select',
+                    options: [{ value: 'provider default', label: 'provider default' }, ...CODEX_REASONING_EFFORTS.map(level => ({ value: level, label: level }))],
+                    description: 'Global default. Model and provider overrides take precedence.',
+                },
+                {
+                    name: 'codexFastMode', label: 'Fast mode', value: String(config.codexFastMode === true), type: 'select',
+                    options: [{ value: 'true', label: 'on' }, { value: 'false', label: 'off' }],
+                    description: 'Request the priority service tier on supported Codex and GPT models.',
+                },
+                configuredSetting(ctx, 'codexEffortByProvider', 'Provider effort overrides', `${Object.keys(config.codexEffortByProvider ?? {}).length} configured`, 'Use /config effort provider <provider> <level|clear> to edit.'),
+                configuredSetting(ctx, 'codexEffortByModel', 'Model effort overrides', `${Object.keys(config.codexEffortByModel ?? {}).length} configured`, 'Use /config effort model <model> <level|clear> to edit.'),
             ],
         },
         {
@@ -182,6 +279,29 @@ export async function buildSettingsCategories(ctx) {
         {
             name: 'Auth & Routing',
             settings: [
+                {
+                    name: 'zrouterAuth',
+                    label: routerSignedIn ? 'Log out of ZRouter' : 'Log in to ZRouter',
+                    value: routerSignedIn ? `Signed in to ${routerCredentials.origin}` : routerCredentials ? 'Session expired' : 'Not signed in',
+                    type: 'text',
+                    description: routerSignedIn
+                        ? 'Revoke this Router session and restore the routing settings from before login.'
+                        : 'Open the Router login in your browser. The confirmation code appears in the transcript.',
+                    onActivate: async () => {
+                        ctx.settingsPanel?.closeSettingsPanel?.();
+                        const action = routerSignedIn ? 'logout' : 'login';
+                        const origin = routerLoginOrigin(config, routerCredentials?.origin);
+                        try {
+                            await authCommand.handler(action === 'login' && origin ? [action, '--url', origin] : [action], ctx);
+                            if (await routerSessionIsCurrent() !== routerSignedIn) {
+                                await settingsCommand.handler(['auth'], ctx);
+                            }
+                        }
+                        catch (error) {
+                            ctx.addMessage({ role: 'system', content: error instanceof Error ? error.message : 'ZRouter authentication failed.' });
+                        }
+                    },
+                },
                 {
                     name: 'authMode',
                     label: 'LLM routing mode',
@@ -229,7 +349,7 @@ export async function buildSettingsCategories(ctx) {
                     value: openaiCompat.baseUrl || config.openaiCompatibleBaseUrl || '',
                     type: 'text',
                     placeholder: 'http://localhost:11434/v1',
-                    visibleWhen: appliesWhen('provider', 'openai_compatible'),
+                    description: 'Used when Custom Endpoint is the selected provider.',
                 },
                 {
                     name: 'openaiCompatibleApiPath',
@@ -237,7 +357,7 @@ export async function buildSettingsCategories(ctx) {
                     value: openaiCompat.apiPath || '/chat/completions',
                     type: 'text',
                     placeholder: '/chat/completions',
-                    visibleWhen: appliesWhen('provider', 'openai_compatible'),
+                    description: 'Used when Custom Endpoint is the selected provider.',
                 },
                 {
                     name: 'openaiCompatibleModel',
@@ -245,8 +365,11 @@ export async function buildSettingsCategories(ctx) {
                     value: openaiCompat.defaultModel || '',
                     type: 'text',
                     placeholder: 'llama3.1, qwen2.5-coder, ...',
-                    visibleWhen: appliesWhen('provider', 'openai_compatible'),
+                    description: 'Used when Custom Endpoint is the selected provider.',
                 },
+                { name: 'openaiCompatibleLabel', label: 'Endpoint label', value: openaiCompat.label ?? '', type: 'text', placeholder: 'Custom Endpoint' },
+                configuredSetting(ctx, 'openaiCompatibleHeaders', 'Custom endpoint headers', `${Object.keys(openaiCompat.headers ?? {}).length} configured`, 'Edit openaiCompatible.headers in ~/.ztc/config.json. Header values are not displayed here.'),
+                configuredSetting(ctx, 'openaiCompatibleSystemPromptSuffix', 'Endpoint prompt suffix', openaiCompat.systemPromptSuffix ? `${openaiCompat.systemPromptSuffix.length} characters` : 'none', 'Edit openaiCompatible.systemPromptSuffix in ~/.ztc/config.json.'),
             ],
         },
         {
@@ -272,7 +395,7 @@ export async function buildSettingsCategories(ctx) {
                         { value: 'sonnet', label: 'sonnet', description: 'Recommended default for Claude Code' },
                         { value: 'opus', label: 'opus', description: 'Use only if your Claude plan supports it' },
                     ],
-                    visibleWhen: appliesWhen('provider', 'claude_code'),
+                    description: 'Used when Claude Code is the selected provider.',
                 },
             ],
         },
@@ -319,12 +442,16 @@ export async function buildSettingsCategories(ctx) {
                     placeholder: 'off',
                     description: 'Turn cap for an autonomous /goal run. Any whole number of turns, or "off" to run uncapped (default).',
                 },
+                {
+                    name: 'maxConsecutiveAutoContinues', label: 'Auto-continues per turn',
+                    value: String(config.maxConsecutiveAutoContinues ?? 3), type: 'text',
+                    description: 'Maximum consecutive follow-up model calls without a tool call. Positive whole number.',
+                },
             ],
         },
         {
-            // Everything that decides how a full context window shrinks lives here:
-            // when to compact, by which strategy, and that strategy's knobs. The Jev
-            // knobs stay hidden until jev is the selected strategy.
+            // Show both trigger inputs and Jev options so they can be prepared before
+            // changing the active compaction mode.
             name: 'Context Compaction',
             settings: [
                 {
@@ -332,7 +459,7 @@ export async function buildSettingsCategories(ctx) {
                     label: 'Trigger on',
                     value: compactionTriggerMode,
                     type: 'select',
-                    description: 'Which rule starts an auto-compaction. The trigger row below follows this choice, so only the one in force is listed.',
+                    description: 'Choose whether context percentage or token count starts auto-compaction.',
                     options: [
                         { value: 'percent', label: 'context %', description: 'Compact at a share of the model\'s context window (default)' },
                         { value: 'tokens', label: 'token count', description: 'Compact at an absolute token count, however large the advertised window is' },
@@ -344,8 +471,7 @@ export async function buildSettingsCategories(ctx) {
                     value: String(resolveAutoCompactThreshold(config)),
                     type: 'text',
                     placeholder: `${minAutoCompactThresholdFor(config)}-${MAX_AUTO_COMPACT_THRESHOLD}`,
-                    description: 'Auto-compact once the context reaches this share of the model window.',
-                    visibleWhen: percentTriggerSelected,
+                    description: 'Applies when Trigger on is context %. Auto-compact at this share of the model window.',
                 },
                 {
                     name: 'contextTokenBudget',
@@ -360,8 +486,7 @@ export async function buildSettingsCategories(ctx) {
                     // The placeholder is what switching to this mode would seed: the
                     // current window percentage expressed in tokens.
                     placeholder: String(defaultTokenTrigger(resolveAutoCompactThreshold(config), model)),
-                    description: 'Absolute token count that triggers auto-compaction, for a wide window you would rather not fill.',
-                    visibleWhen: tokenTriggerSelected,
+                    description: 'Applies when Trigger on is token count. Absolute count that starts auto-compaction.',
                 },
                 {
                     name: 'compactionTargetPercent',
@@ -383,10 +508,10 @@ export async function buildSettingsCategories(ctx) {
                         { value: 'jev', label: 'jev', description: 'Delete only the tool calls and outputs Jev says are stale; everything kept stays verbatim. Requires a Router login (ztc auth login). Falls back to summary if Jev is unreachable.' },
                     ],
                 },
-                { name: 'jevModel', label: 'Jev model', value: compaction.jev.model, type: 'text', placeholder: DEFAULT_JEV_SETTINGS.model, visibleWhen: jevSelected },
-                { name: 'jevKeepThreshold', label: 'Jev keep threshold', value: String(compaction.jev.keepThreshold), type: 'text', placeholder: '0.5', visibleWhen: jevSelected },
-                { name: 'jevPreserveRecent', label: 'Jev protect recent messages', value: String(compaction.jev.preserveRecentMessages), type: 'text', placeholder: '6', visibleWhen: jevSelected },
-                { name: 'jevMaxStateTokens', label: 'Jev state budget (tokens)', value: String(compaction.jev.maxStateTokens), type: 'text', placeholder: '25000', visibleWhen: jevSelected },
+                { name: 'jevModel', label: 'Jev model', value: compaction.jev.model, type: 'text', placeholder: DEFAULT_JEV_SETTINGS.model, description: 'Applies when Strategy is jev.' },
+                { name: 'jevKeepThreshold', label: 'Jev keep threshold', value: String(compaction.jev.keepThreshold), type: 'text', placeholder: '0.5', description: 'Applies when Strategy is jev.' },
+                { name: 'jevPreserveRecent', label: 'Jev protect recent messages', value: String(compaction.jev.preserveRecentMessages), type: 'text', placeholder: '6', description: 'Applies when Strategy is jev.' },
+                { name: 'jevMaxStateTokens', label: 'Jev state budget (tokens)', value: String(compaction.jev.maxStateTokens), type: 'text', placeholder: '25000', description: 'Applies when Strategy is jev.' },
             ],
         },
         {
@@ -495,7 +620,7 @@ export async function buildSettingsCategories(ctx) {
                     // Picking and ordering happen on the editor page; the value stays the
                     // summary so this row still reads as the current line.
                     onActivate: () => ctx.statusLinePanel?.open({ side: 'left' }),
-                    visibleWhen: statusLineShown,
+                    description: 'Applies when Show status line is on.',
                 },
                 {
                     name: 'statusLineRight',
@@ -504,7 +629,7 @@ export async function buildSettingsCategories(ctx) {
                     type: 'checkbox-list',
                     options: STATUS_LINE_FIELD_OPTIONS,
                     onActivate: () => ctx.statusLinePanel?.open({ side: 'right' }),
-                    visibleWhen: statusLineShown,
+                    description: 'Applies when Show status line is on.',
                 },
                 {
                     name: 'statusLineSeparator',
@@ -519,7 +644,7 @@ export async function buildSettingsCategories(ctx) {
                         { value: ' • ', label: '• Bullet' },
                         { value: ' ', label: 'Space' },
                     ], statusLine.separator, value => JSON.stringify(value)),
-                    visibleWhen: statusLineShown,
+                    description: 'Applies when Show status line is on.',
                 },
                 {
                     name: 'statusLineColors',
@@ -530,7 +655,7 @@ export async function buildSettingsCategories(ctx) {
                         { value: 'true', label: 'on', description: 'Use semantic colors and the status background' },
                         { value: 'false', label: 'off', description: 'Use the terminal default colors' },
                     ],
-                    visibleWhen: statusLineShown,
+                    description: 'Applies when Show status line is on.',
                 },
             ],
         },
@@ -547,15 +672,16 @@ export async function buildSettingsCategories(ctx) {
                         { value: 'false', label: 'off', description: 'Hide the context progress bar and restore the input border' },
                     ],
                 },
-                { name: 'contextProgressBarAccentColor', label: 'Accent color', value: contextProgressBar.accentColor || '#58a6ff', type: 'color', placeholder: '#58a6ff', visibleWhen: progressBarShown },
-                { name: 'contextProgressBarWarningColor', label: 'Warning color', value: contextProgressBar.warningColor || '#d29922', type: 'color', placeholder: '#d29922', visibleWhen: progressBarShown },
-                { name: 'contextProgressBarCriticalColor', label: 'Critical color', value: contextProgressBar.criticalColor || '#f85149', type: 'color', placeholder: '#f85149', visibleWhen: progressBarShown },
-                { name: 'contextProgressBarTrackColor', label: 'Track color', value: contextProgressBar.trackColor || 'rgba(88, 166, 255, 0.16)', type: 'color', placeholder: 'rgba(88, 166, 255, 0.16)', visibleWhen: progressBarShown },
+                { name: 'contextProgressBarAccentColor', label: 'Accent color', value: contextProgressBar.accentColor || '#58a6ff', type: 'color', placeholder: '#58a6ff', description: 'Applies when the context progress bar is on.' },
+                { name: 'contextProgressBarWarningColor', label: 'Warning color', value: contextProgressBar.warningColor || '#d29922', type: 'color', placeholder: '#d29922', description: 'Applies when the context progress bar is on.' },
+                { name: 'contextProgressBarCriticalColor', label: 'Critical color', value: contextProgressBar.criticalColor || '#f85149', type: 'color', placeholder: '#f85149', description: 'Applies when the context progress bar is on.' },
+                { name: 'contextProgressBarTrackColor', label: 'Track color', value: contextProgressBar.trackColor || 'rgba(88, 166, 255, 0.16)', type: 'color', placeholder: 'rgba(88, 166, 255, 0.16)', description: 'Applies when the context progress bar is on.' },
             ],
         },
         {
             name: 'MCP Servers',
             settings: [
+                configuredSetting(ctx, 'mcpServers', 'Configured MCP servers', `${Object.keys(config.mcpServers ?? {}).length} configured`, 'Edit mcpServers in ~/.ztc/config.json; use /mcp for connection details.'),
                 {
                     name: 'mcpColonyAutoAttach',
                     label: 'Attach to local colony',
@@ -580,6 +706,9 @@ export async function buildSettingsCategories(ctx) {
         {
             name: 'Panes',
             settings: [
+                { name: 'uiTheme', label: 'Theme', value: config.uiTheme ?? 'ztc-dark', type: 'text', description: 'Terminal theme name. Use /theme list for built-in choices.' },
+                { name: 'rawScrollback', label: 'Raw scrollback', value: String(config.rawScrollback === true), type: 'select', options: [{ value: 'true', label: 'on' }, { value: 'false', label: 'off' }] },
+                { name: 'keybindings', label: 'Keybindings', value: `${Object.keys(config.keybindings?.zmux ?? {}).length} overrides`, type: 'text', description: 'Enter to edit shortcuts.', onActivate: () => { void keybindingsCommand.handler([], ctx); } },
                 {
                     name: 'panesCustomOptions',
                     label: 'Custom pane options',
@@ -614,7 +743,7 @@ export async function buildSettingsCategories(ctx) {
                 },
                 {
                     name: 'sfxVolume',
-                    visibleWhen: soundEnabled,
+                    description: 'Applies when Notifications are on.',
                     label: 'Volume',
                     // Volume is continuous, so a four-item menu could not express it and
                     // `/sfx volume 0.3` produced a row with nothing selected. Any volume
@@ -626,7 +755,7 @@ export async function buildSettingsCategories(ctx) {
                 },
                 {
                     name: 'sfxPack',
-                    visibleWhen: soundEnabled,
+                    description: 'Applies when Notifications are on.',
                     label: 'Sound pack',
                     // Every installed pack, not four of them: the catalogue ships dozens
                     // and `/sfx pack <name>` reaches all of them.
@@ -639,6 +768,123 @@ export async function buildSettingsCategories(ctx) {
                 },
             ],
         },
+        {
+            name: 'Tool Access',
+            settings: [
+                { name: 'permissionProfile', label: 'Permission profile', value: config.permissionProfile ?? 'trusted', type: 'select',
+                    options: withCurrentValue(Object.keys(config.permissionProfiles ?? {}).map(id => ({ value: id, label: id })), config.permissionProfile ?? 'trusted', value => value) },
+                configuredSetting(ctx, 'permissionProfiles', 'Permission profiles', `${Object.keys(config.permissionProfiles ?? {}).length} configured`, 'Edit custom profiles in ~/.ztc/config.json; use /permissions profiles to inspect them.'),
+                ...['file_read', 'file_write', 'shell_exec', 'network', 'screen_capture', 'computer_control', 'ml_inference'].map(capability => toggleSetting(`toolPermission_${capability}`, `Allow ${capability.replaceAll('_', ' ')}`, config.toolPermissions?.[capability] !== false)),
+                toggleSetting('sandboxEnabled', 'Process sandbox', config.sandbox?.enabled !== false),
+                { name: 'sandboxBackend', label: 'Sandbox backend', value: config.sandbox?.backend ?? 'auto', type: 'select',
+                    options: ['auto', 'none', 'seatbelt', 'bubblewrap', 'windows-job'].map(backend => ({ value: backend, label: backend })) },
+                toggleSetting('sandboxRequireOsEnforcement', 'Require OS sandbox', config.sandbox?.requireOsEnforcement === true),
+                { name: 'sandboxAuditDir', label: 'Sandbox audit directory', value: config.sandbox?.auditDir ?? '', type: 'text', placeholder: 'default' },
+                toggleSetting('intentsEnabled', 'Intent files', config.intents?.enabled === true),
+                toggleSetting('intentsAutoWrite', 'Write intent notes', config.intents?.autoWrite === true, 'Applies when Intent files are on.'),
+                { name: 'intentsMaxBytes', label: 'Intent context bytes', value: String(config.intents?.maxBytes ?? 32_768), type: 'text' },
+                { name: 'intentsFileThreshold', label: 'File intent threshold', value: String(config.intents?.fileIntentThresholdLines ?? 400), type: 'text' },
+                toggleSetting('intentsInChildPanes', 'Intents in child panes', config.intents?.includeInChildPanes !== false),
+                configuredSetting(ctx, 'hooks', 'Lifecycle hooks', `${Object.values(config.hooks ?? {}).reduce((n, entries) => n + (entries?.length ?? 0), 0)} configured`, 'Edit hooks in ~/.ztc/config.json; use /hooks to inspect active hooks.'),
+            ],
+        },
+        {
+            name: 'Automation',
+            settings: [
+                toggleSetting('skillsEnabled', 'Skills', config.skills?.enabled !== false),
+                { name: 'skillsRoots', label: 'Extra skill roots', value: JSON.stringify(config.skills?.roots ?? []), type: 'text', description: 'JSON array of absolute paths.' },
+                { name: 'skillsDisabled', label: 'Disabled skills', value: JSON.stringify(config.skills?.disabled ?? []), type: 'text', description: 'JSON array of skill ids. Use /skills list to inspect ids.' },
+                toggleSetting('workflowsEnabled', 'Workflows', config.workflows?.enabled !== false),
+                toggleSetting('workflowsNaturalLanguageTrigger', 'Natural language workflows', config.workflows?.naturalLanguageTrigger !== false),
+                { name: 'workflowsMaxConcurrency', label: 'Workflow concurrency', value: String(config.workflows?.maxConcurrency ?? 4), type: 'text' },
+                { name: 'workflowsMaxAgents', label: 'Workflow agent cap', value: String(config.workflows?.maxAgents ?? 50), type: 'text' },
+                { name: 'workflowsTimeoutMs', label: 'Workflow timeout (ms)', value: String(config.workflows?.workflowTimeoutMs ?? 43_200_000), type: 'text' },
+            ],
+        },
+        {
+            name: 'Context Storage',
+            settings: [
+                toggleSetting('offloadEnabled', 'Tool result offload', config.offloadEnabled === true),
+                { name: 'inlineSizeThresholdTokens', label: 'Inline result size (tokens)', value: String(config.inlineSizeThresholdTokens ?? 2000), type: 'text', description: 'Applies when Tool result offload is on.' },
+                { name: 'inlineAgeTurns', label: 'Inline result age (turns)', value: String(config.inlineAgeTurns ?? 8), type: 'text', description: 'Applies when Tool result offload is on.' },
+                { name: 'toolCompression', label: 'Tool result compression', value: config.toolCompression ?? 'off', type: 'select',
+                    options: ['off', 'safe', 'aggressive'].map(level => ({ value: level, label: level })), description: 'Applies when Tool result offload is on.' },
+            ],
+        },
+        {
+            name: 'Voice & Dictation',
+            settings: [
+                toggleSetting('voiceEnabled', 'Speak responses', config.voice?.enabled === true),
+                { name: 'voiceProvider', label: 'Voice provider', value: config.voice?.provider ?? 'say', type: 'select',
+                    options: ['say', 'parler', 'openai', 'elevenlabs'].map(value => ({ value, label: value })) },
+                { name: 'voiceModel', label: 'Parler model', value: config.voice?.model ?? 'mini', type: 'select', options: ['mini', 'large'].map(value => ({ value, label: value })) },
+                { name: 'voiceDescription', label: 'Parler voice description', value: config.voice?.description ?? '', type: 'text' },
+                { name: 'voiceSayVoice', label: 'macOS voice', value: config.voice?.sayVoice ?? '', type: 'text', placeholder: 'system default' },
+                { name: 'voiceSayRate', label: 'macOS speech rate', value: String(config.voice?.sayRate ?? 175), type: 'text' },
+                { name: 'voiceOpenaiKey', label: 'OpenAI voice key', value: config.voice?.openaiKey ?? '', type: 'text', secret: true },
+                { name: 'voiceOpenaiVoice', label: 'OpenAI voice', value: config.voice?.openaiVoice ?? 'alloy', type: 'select', options: ['alloy', 'echo', 'fable', 'onyx', 'nova', 'shimmer'].map(value => ({ value, label: value })) },
+                { name: 'voiceOpenaiModel', label: 'OpenAI speech model', value: config.voice?.openaiModel ?? 'tts-1', type: 'select', options: ['tts-1', 'tts-1-hd'].map(value => ({ value, label: value })) },
+                { name: 'voiceElevenlabsKey', label: 'ElevenLabs key', value: config.voice?.elevenlabsKey ?? '', type: 'text', secret: true },
+                { name: 'voiceElevenlabsVoice', label: 'ElevenLabs voice ID', value: config.voice?.elevenlabsVoice ?? '', type: 'text' },
+                { name: 'voiceElevenlabsModel', label: 'ElevenLabs model ID', value: config.voice?.elevenlabsModel ?? '', type: 'text' },
+                { name: 'dictationProvider', label: 'Dictation provider', value: config.dictation?.provider ?? 'local', type: 'select',
+                    options: ['local', 'openai', 'macos'].map(value => ({ value, label: value })) },
+                { name: 'dictationLanguage', label: 'Dictation language', value: config.dictation?.language ?? '', type: 'text', placeholder: 'auto' },
+                { name: 'dictationModel', label: 'Whisper model', value: config.dictation?.whisperModel ?? 'tiny', type: 'select',
+                    options: ['tiny', 'base', 'small', 'medium', 'large'].map(value => ({ value, label: value })) },
+                { name: 'dictationDevice', label: 'Input device', value: config.dictation?.device ?? '', type: 'text', placeholder: 'system default' },
+            ],
+        },
+        {
+            name: 'Runtime Integrations',
+            settings: [
+                { name: 'manifestsDir', label: 'Manifests directory', value: config.manifestsDir ?? '', type: 'text', placeholder: '~/.ztc/manifests' },
+                { name: 'spinnerVerbs', label: 'Spinner verbs', value: (config.spinnerVerbs ?? DEFAULT_SPINNER_VERBS).join(', '), type: 'text', description: 'Comma-separated list; blank restores defaults.' },
+                { name: 'simProvider', label: 'Simulation provider', value: config.simProvider ?? 'openai', type: 'text' },
+                { name: 'simModel', label: 'Simulation model', value: config.simModel ?? 'gpt-5.4-mini', type: 'text' },
+                { name: 'emulationId', label: 'Emulation ID', value: config.emulationId ?? '', type: 'text', placeholder: 'none',
+                    description: builtinProfileEmulation(activeProfile()) ? 'This built-in profile selects the prompt. Edits here last for this session.' : undefined },
+                { name: 'shannonRepoUrl', label: 'Shannon repository', value: config.shannon?.repoUrl ?? '', type: 'text' },
+                { name: 'shannonLocalPath', label: 'Shannon local path', value: config.shannon?.localPath ?? '', type: 'text' },
+                configuredSetting(ctx, 'shannonPinnedCommit', 'Shannon pinned commit', config.shannon?.pinnedCommit ?? 'none', 'Managed by Shannon sync; use /shannon to inspect it.'),
+                configuredSetting(ctx, 'shannonLastSyncAt', 'Shannon last sync', config.shannon?.lastSyncAt ?? 'never', 'Managed by Shannon sync.'),
+                { name: 'shannonRunnerCommand', label: 'Shannon runner command', value: config.shannon?.runnerCommand ?? '', type: 'text' },
+                { name: 'shannonRunnerArgs', label: 'Shannon runner arguments', value: JSON.stringify(config.shannon?.runnerArgs ?? []), type: 'text', description: 'JSON array of arguments.' },
+                { name: 'shannonRunnerCwd', label: 'Shannon runner directory', value: config.shannon?.runnerCwd ?? '', type: 'text' },
+                { name: 'shannonApiBaseUrl', label: 'Shannon API URL', value: config.shannon?.apiBaseUrl ?? '', type: 'text' },
+                configuredSetting(ctx, 'hostedThreadInstructions', 'Hosted instructions', config.hostedThreadInstructions ? 'configured' : 'none', 'Managed by the hosted session; content is not shown in settings.'),
+                configuredSetting(ctx, 'zrouterRoutePlan', 'Hosted route plan', config.zrouterRoutePlan ? 'configured' : 'none', 'Managed by the hosted session.'),
+                configuredSetting(ctx, 'auth', 'Platform login', config.auth?.email ?? 'not signed in', 'Use /auth to manage platform credentials.'),
+                configuredSetting(ctx, 'apiKey', 'Legacy API key', config.apiKey ? 'configured' : 'none', 'Use the provider keys above. Secret values are never displayed here.'),
+                { name: 'codexAppServerCommand', label: 'Codex App Server command', value: config.codexAppServer?.command ?? 'codex', type: 'text' },
+                { name: 'codexAppServerArgs', label: 'Codex App Server arguments', value: JSON.stringify(config.codexAppServer?.args ?? ['app-server']), type: 'text', description: 'JSON array of arguments.' },
+                configuredSetting(ctx, 'codexAppServerLoginFlow', 'Codex login flow', config.codexAppServer?.loginFlow ?? 'cached', 'The App Server currently uses cached credentials; this stored field is informational.'),
+                { name: 'codexAppServerSandbox', label: 'Codex sandbox', value: config.codexAppServer?.sandbox ?? 'workspace-write', type: 'select',
+                    options: ['read-only', 'workspace-write', 'danger-full-access'].map(value => ({ value, label: value })) },
+            ],
+        },
+    ];
+    const byName = new Map(sections.map(section => [section.name, section.settings]));
+    const group = (name, ...sectionNames) => ({
+        name,
+        settings: sectionNames.flatMap(sectionName => {
+            const settings = byName.get(sectionName);
+            if (!settings)
+                throw new Error(`Missing settings section: ${sectionName}`);
+            return settings;
+        }),
+    });
+    return [
+        group('Accounts', 'Config Scope', 'Accounts'),
+        group('Provider & Model', 'Provider & Model', 'Claude Code'),
+        group('Auth & Routing', 'Auth & Routing', 'API Keys', 'Custom Endpoint'),
+        group('Behavior', 'Behavior', 'Retries & Timeouts', 'Automation'),
+        group('Context Compaction', 'Context Compaction', 'Context Storage'),
+        group('Tools & Security', 'Tool Access'),
+        group('Verbosity', 'Verbosity', 'Panes'),
+        group('Status Line', 'Status Line', 'Context Progress Bar'),
+        group('Integrations', 'MCP Servers', 'Runtime Integrations'),
+        group('Sound', 'Sound', 'Voice & Dictation'),
     ];
 }
 /** Summary for the custom-option row: what the chooser will actually offer. */
@@ -779,6 +1025,14 @@ function openCustomPaneManager(ctx, reopen) {
     showList();
 }
 function applySettingChange(ctx, setting, value) {
+    if (setting.startsWith('toolPermission_')) {
+        const capability = setting.slice('toolPermission_'.length);
+        if (!['file_read', 'file_write', 'shell_exec', 'network', 'screen_capture', 'computer_control', 'ml_inference'].includes(capability)) {
+            throw new Error(`Unknown tool permission: ${capability}`);
+        }
+        ctx.config.set('toolPermissions', { ...ctx.config.get().toolPermissions, [capability]: value === 'true' });
+        return;
+    }
     switch (setting) {
         case 'provider':
             ctx.config.setProvider(value);
@@ -791,6 +1045,28 @@ function applySettingChange(ctx, setting, value) {
         case 'model':
             ctx.config.set('model', value);
             break;
+        case 'maxTokens': {
+            const input = value.trim();
+            if (input === '' || input.toLowerCase() === 'provider default' || input.toLowerCase() === 'off') {
+                ctx.config.set('maxTokens', undefined);
+                break;
+            }
+            const count = Number(input);
+            if (!/^[1-9]\d*$/.test(input) || !Number.isSafeInteger(count)) {
+                throw new Error('Max tokens must be a positive whole number within the safe integer range, or "provider default".');
+            }
+            ctx.config.set('maxTokens', count);
+            break;
+        }
+        case 'codexEffort':
+            if (value !== 'provider default' && !CODEX_REASONING_EFFORTS.includes(value)) {
+                throw new Error(`Unknown reasoning effort: ${value}`);
+            }
+            ctx.config.set('codexEffort', value === 'provider default' ? undefined : value);
+            break;
+        case 'codexFastMode':
+            ctx.config.set('codexFastMode', value === 'true');
+            break;
         case 'claudeCodeModel':
             ctx.config.setProvider('claude_code');
             ctx.config.set('model', value);
@@ -857,6 +1133,12 @@ function applySettingChange(ctx, setting, value) {
             if (ctx.config.setOpenAICompatibleSettings)
                 ctx.config.setOpenAICompatibleSettings({ defaultModel: value || undefined });
             break;
+        case 'openaiCompatibleLabel':
+            if (ctx.config.setOpenAICompatibleSettings)
+                ctx.config.setOpenAICompatibleSettings({ label: value.trim() || undefined });
+            else
+                ctx.config.set('openaiCompatible', { ...ctx.config.get().openaiCompatible, label: value.trim() || undefined });
+            break;
         case 'autoContinue':
             if (ctx.config.setAutoContinue)
                 ctx.config.setAutoContinue(value === 'true');
@@ -951,6 +1233,9 @@ function applySettingChange(ctx, setting, value) {
             ctx.config.set('maxIterations', cap);
             break;
         }
+        case 'maxConsecutiveAutoContinues':
+            ctx.config.set('maxConsecutiveAutoContinues', wholeCount(value, 'Auto-continues per turn'));
+            break;
         case 'goalMaxTurns': {
             // The persistent switch for the autonomous /goal turn cap. Values are the
             // same vocabulary as /config goal-max-turns; 'off' clears the cap.
@@ -1122,6 +1407,196 @@ function applySettingChange(ctx, setting, value) {
         case 'mcpStatus':
             // Read-only informational setting.
             break;
+        case 'permissionProfile':
+            if (!ctx.config.get().permissionProfiles?.[value])
+                throw new Error(`Unknown permission profile: ${value}`);
+            ctx.config.set('permissionProfile', value);
+            break;
+        case 'sandboxEnabled':
+            ctx.config.set('sandbox', { ...ctx.config.get().sandbox, enabled: value === 'true' });
+            break;
+        case 'sandboxBackend':
+            if (!['auto', 'none', 'seatbelt', 'bubblewrap', 'windows-job'].includes(value))
+                throw new Error(`Unknown sandbox backend: ${value}`);
+            ctx.config.set('sandbox', { ...ctx.config.get().sandbox, backend: value });
+            break;
+        case 'sandboxRequireOsEnforcement':
+            ctx.config.set('sandbox', { ...ctx.config.get().sandbox, requireOsEnforcement: value === 'true' });
+            break;
+        case 'sandboxAuditDir':
+            ctx.config.set('sandbox', { ...ctx.config.get().sandbox, auditDir: value.trim() || undefined });
+            break;
+        case 'intentsEnabled':
+            ctx.config.set('intents', { ...ctx.config.get().intents, enabled: value === 'true' });
+            break;
+        case 'intentsAutoWrite':
+            ctx.config.set('intents', { ...ctx.config.get().intents, autoWrite: value === 'true' });
+            break;
+        case 'intentsMaxBytes':
+            ctx.config.set('intents', { ...ctx.config.get().intents, maxBytes: wholeCount(value, 'Intent context bytes') });
+            break;
+        case 'intentsFileThreshold':
+            ctx.config.set('intents', { ...ctx.config.get().intents, fileIntentThresholdLines: wholeCount(value, 'File intent threshold') });
+            break;
+        case 'intentsInChildPanes':
+            ctx.config.set('intents', { ...ctx.config.get().intents, includeInChildPanes: value === 'true' });
+            break;
+        case 'skillsEnabled':
+            ctx.config.set('skills', { ...ctx.config.get().skills, enabled: value === 'true' });
+            break;
+        case 'skillsRoots':
+            ctx.config.set('skills', { ...ctx.config.get().skills, roots: stringArray(value, 'Extra skill roots') });
+            break;
+        case 'skillsDisabled':
+            ctx.config.set('skills', { ...ctx.config.get().skills, disabled: stringArray(value, 'Disabled skills') });
+            break;
+        case 'workflowsEnabled':
+            ctx.config.set('workflows', { ...ctx.config.get().workflows, enabled: value === 'true' });
+            break;
+        case 'workflowsNaturalLanguageTrigger':
+            ctx.config.set('workflows', { ...ctx.config.get().workflows, naturalLanguageTrigger: value === 'true' });
+            break;
+        case 'workflowsMaxConcurrency':
+            ctx.config.set('workflows', { ...ctx.config.get().workflows, maxConcurrency: wholeCount(value, 'Workflow concurrency', 1, 16) });
+            break;
+        case 'workflowsMaxAgents':
+            ctx.config.set('workflows', { ...ctx.config.get().workflows, maxAgents: wholeCount(value, 'Workflow agent cap', 1, 1000) });
+            break;
+        case 'workflowsTimeoutMs':
+            ctx.config.set('workflows', { ...ctx.config.get().workflows, workflowTimeoutMs: wholeCount(value, 'Workflow timeout', 1, 2_147_483_647) });
+            break;
+        case 'offloadEnabled':
+            ctx.config.set('offloadEnabled', value === 'true');
+            break;
+        case 'inlineSizeThresholdTokens':
+            ctx.config.set('inlineSizeThresholdTokens', wholeCount(value, 'Inline result size', 0));
+            break;
+        case 'inlineAgeTurns':
+            ctx.config.set('inlineAgeTurns', wholeCount(value, 'Inline result age', 0));
+            break;
+        case 'toolCompression':
+            if (value !== 'off' && value !== 'safe' && value !== 'aggressive')
+                throw new Error(`Unknown tool compression: ${value}`);
+            ctx.config.set('toolCompression', value);
+            break;
+        case 'voiceEnabled':
+            ctx.config.set('voice', { ...ctx.config.get().voice, enabled: value === 'true' });
+            break;
+        case 'voiceProvider':
+            if (value !== 'say' && value !== 'parler' && value !== 'openai' && value !== 'elevenlabs')
+                throw new Error(`Unknown voice provider: ${value}`);
+            ctx.config.set('voice', { ...ctx.config.get().voice, provider: value });
+            break;
+        case 'voiceModel':
+            if (value !== 'mini' && value !== 'large')
+                throw new Error(`Unknown Parler model: ${value}`);
+            ctx.config.set('voice', { ...ctx.config.get().voice, model: value });
+            break;
+        case 'voiceDescription':
+            ctx.config.set('voice', { ...ctx.config.get().voice, description: value.trim() || undefined });
+            break;
+        case 'voiceSayVoice':
+            ctx.config.set('voice', { ...ctx.config.get().voice, sayVoice: value.trim() || undefined });
+            break;
+        case 'voiceSayRate':
+            ctx.config.set('voice', { ...ctx.config.get().voice, sayRate: wholeCount(value, 'macOS speech rate') });
+            break;
+        case 'voiceOpenaiKey':
+            ctx.config.set('voice', { ...ctx.config.get().voice, openaiKey: value || undefined });
+            break;
+        case 'voiceOpenaiVoice':
+            if (!['alloy', 'echo', 'fable', 'onyx', 'nova', 'shimmer'].includes(value))
+                throw new Error(`Unknown OpenAI voice: ${value}`);
+            ctx.config.set('voice', { ...ctx.config.get().voice, openaiVoice: value });
+            break;
+        case 'voiceOpenaiModel':
+            if (value !== 'tts-1' && value !== 'tts-1-hd')
+                throw new Error(`Unknown OpenAI speech model: ${value}`);
+            ctx.config.set('voice', { ...ctx.config.get().voice, openaiModel: value });
+            break;
+        case 'voiceElevenlabsKey':
+            ctx.config.set('voice', { ...ctx.config.get().voice, elevenlabsKey: value || undefined });
+            break;
+        case 'voiceElevenlabsVoice':
+            ctx.config.set('voice', { ...ctx.config.get().voice, elevenlabsVoice: value.trim() || undefined });
+            break;
+        case 'voiceElevenlabsModel':
+            ctx.config.set('voice', { ...ctx.config.get().voice, elevenlabsModel: value.trim() || undefined });
+            break;
+        case 'dictationProvider':
+            if (value !== 'local' && value !== 'openai' && value !== 'macos')
+                throw new Error(`Unknown dictation provider: ${value}`);
+            ctx.config.set('dictation', { ...ctx.config.get().dictation, provider: value });
+            break;
+        case 'dictationLanguage':
+            ctx.config.set('dictation', { ...ctx.config.get().dictation, language: value.trim() || undefined });
+            break;
+        case 'dictationModel':
+            if (value !== 'tiny' && value !== 'base' && value !== 'small' && value !== 'medium' && value !== 'large')
+                throw new Error(`Unknown Whisper model: ${value}`);
+            ctx.config.set('dictation', { ...ctx.config.get().dictation, whisperModel: value });
+            break;
+        case 'dictationDevice':
+            ctx.config.set('dictation', { ...ctx.config.get().dictation, device: value.trim() || undefined });
+            break;
+        case 'uiTheme':
+            if (!value.trim())
+                throw new Error('Theme name cannot be empty.');
+            ctx.config.set('uiTheme', value.trim());
+            break;
+        case 'rawScrollback':
+            ctx.config.set('rawScrollback', value === 'true');
+            break;
+        case 'manifestsDir':
+            ctx.config.set('manifestsDir', value.trim() || undefined);
+            break;
+        case 'spinnerVerbs':
+            ctx.config.set('spinnerVerbs', value.trim() ? parseSpinnerVerbs(value) : DEFAULT_SPINNER_VERBS);
+            break;
+        case 'simProvider':
+            if (!value.trim())
+                throw new Error('Simulation provider cannot be empty.');
+            ctx.config.set('simProvider', value.trim());
+            break;
+        case 'simModel':
+            if (!value.trim())
+                throw new Error('Simulation model cannot be empty.');
+            ctx.config.set('simModel', value.trim());
+            break;
+        case 'emulationId':
+            ctx.config.set('emulationId', value.trim() || undefined);
+            break;
+        case 'shannonRepoUrl':
+            ctx.config.set('shannon', { ...ctx.config.get().shannon, repoUrl: value.trim() || undefined });
+            break;
+        case 'shannonLocalPath':
+            ctx.config.set('shannon', { ...ctx.config.get().shannon, localPath: value.trim() || undefined });
+            break;
+        case 'shannonRunnerCommand':
+            ctx.config.set('shannon', { ...ctx.config.get().shannon, runnerCommand: value.trim() || undefined });
+            break;
+        case 'shannonRunnerArgs':
+            ctx.config.set('shannon', { ...ctx.config.get().shannon, runnerArgs: stringArray(value, 'Shannon runner arguments') });
+            break;
+        case 'shannonRunnerCwd':
+            ctx.config.set('shannon', { ...ctx.config.get().shannon, runnerCwd: value.trim() || undefined });
+            break;
+        case 'shannonApiBaseUrl':
+            ctx.config.set('shannon', { ...ctx.config.get().shannon, apiBaseUrl: value.trim() || undefined });
+            break;
+        case 'codexAppServerCommand':
+            if (!value.trim())
+                throw new Error('Codex App Server command cannot be empty.');
+            ctx.config.set('codexAppServer', { ...ctx.config.get().codexAppServer, command: value.trim() });
+            break;
+        case 'codexAppServerArgs':
+            ctx.config.set('codexAppServer', { ...ctx.config.get().codexAppServer, args: stringArray(value, 'Codex App Server arguments') });
+            break;
+        case 'codexAppServerSandbox':
+            if (value !== 'read-only' && value !== 'workspace-write' && value !== 'danger-full-access')
+                throw new Error(`Unknown Codex sandbox: ${value}`);
+            ctx.config.set('codexAppServer', { ...ctx.config.get().codexAppServer, sandbox: value });
+            break;
         case 'sfxEnabled': {
             ctx.config.set('sfx', { ...(ctx.config.get().sfx ?? {}), enabled: value === 'true' });
             break;
@@ -1226,6 +1701,10 @@ function refreshRowDisplays(categories, ctx) {
             setting.value = scope;
         else if (setting.name === 'clearSessionConfig')
             setting.value = 'no';
+        else if (setting.name === 'maxTokens')
+            setting.value = config.maxTokens === undefined ? 'provider default' : String(config.maxTokens);
+        else if (setting.name === 'spinnerVerbs')
+            setting.value = (config.spinnerVerbs ?? DEFAULT_SPINNER_VERBS).join(', ');
         else if (setting.name === 'compactionTriggerMode')
             setting.value = resolveCompactionTriggerMode(config);
         else if (setting.name === 'contextTokenBudget') {
@@ -1240,10 +1719,22 @@ function refreshRowDisplays(categories, ctx) {
         }
     }
 }
+async function refreshAllRowDisplays(categories, ctx) {
+    const fresh = new Map((await buildSettingsCategories(ctx))
+        .flatMap(category => category.settings.map(setting => [setting.name, setting])));
+    for (const row of categories.flatMap(category => category.settings)) {
+        const next = fresh.get(row.name);
+        if (!next)
+            continue;
+        row.value = next.value;
+        row.options = next.options;
+        row.placeholder = next.placeholder;
+    }
+}
 export const settingsCommand = {
     name: 'settings',
     description: 'Interactive settings panel',
-    usage: '/settings [provider|model|keys|behavior|compaction|verbosity|statusline|sound]',
+    usage: '/settings [accounts|provider|routing|behavior|compaction|tools|verbosity|statusline|integrations|sound]',
     handler: async (args, ctx) => {
         if (!ctx.settingsPanel) {
             ctx.addMessage({ role: 'system', content: 'Settings panel not available in this renderer.' });
@@ -1257,9 +1748,25 @@ export const settingsCommand = {
                 ? 'verbosity'
                 : sub;
         const onSettingChange = async (setting, value) => {
+            if (setting === 'workflowsEnabled' && value === 'false') {
+                await shutdownAndClearWorkflowRegistry(5000);
+            }
             applySettingChange(ctx, setting, value);
             await ctx.config.save();
-            refreshRowDisplays(categories, ctx);
+            if (setting === 'skillsEnabled' || setting === 'skillsRoots' || setting === 'skillsDisabled') {
+                invalidateSkillsCache();
+                await preloadSkillsManifest();
+            }
+            if ((setting === 'clearSessionConfig' && value === 'yes')
+                || setting === 'provider' || setting === 'model' || setting === 'claudeCodeModel') {
+                await refreshAllRowDisplays(categories, ctx);
+            }
+            else {
+                const row = categories.flatMap(category => category.settings).find(item => item.name === setting);
+                if (row)
+                    row.value = value;
+                refreshRowDisplays(categories, ctx);
+            }
             if (setting === 'provider' || setting === 'model' || setting === 'claudeCodeModel') {
                 const provider = setting === 'provider'
                     ? value
@@ -1268,7 +1775,7 @@ export const settingsCommand = {
                         : ctx.config.getProvider();
                 applyRuntimeModelSelection(ctx, provider, getEffectiveModel(ctx));
             }
-            else if (!LIVE_READ_SETTINGS.has(setting)) {
+            else if (setting !== 'clearSessionConfig' && !LIVE_READ_SETTINGS.has(setting)) {
                 ctx.reloadAgent();
             }
         };
@@ -1278,10 +1785,15 @@ export const settingsCommand = {
          * reopening `/settings` four times.
          */
         const showSettings = (filter) => {
+            const matches = filter
+                ? categories.filter(category => category.name.toLowerCase().includes(filter.toLowerCase()))
+                : [];
+            const initialCategory = matches.length === 1 ? matches[0].name : undefined;
             ctx.settingsPanel?.showSettingsPanel({
                 title: 'Settings',
                 categories,
-                initialFilter: filter,
+                initialCategory,
+                initialFilter: initialCategory ? undefined : filter,
                 onSettingChange,
             });
         };
@@ -1316,7 +1828,100 @@ export const settingsCommand = {
             if (setting.name === 'panesCustomOptions') {
                 setting.onActivate = () => openCustomPaneManager(ctx, () => showSettings('custom pane options'));
             }
+            if (setting.name === 'factoryReset') {
+                setting.onActivate = () => openFactoryResetConfirmation(ctx, () => settingsCommand.handler(['accounts'], ctx));
+            }
+            if (setting.name === 'configProfile') {
+                setting.onActivate = () => openConfigProfilePicker(ctx).catch(error => {
+                    ctx.addMessage({ role: 'system', content: `Could not open config profiles: ${error.message}` });
+                });
+            }
         }
         showSettings(defaultFilter || undefined);
     },
 };
+async function openConfigProfilePicker(ctx) {
+    if (!ctx.settingsPanel)
+        return;
+    const names = await listConfigProfiles();
+    const reopenSettings = async () => { await settingsCommand.handler(['config'], ctx); };
+    const choose = (name, allowNew = false) => {
+        return switchConfigProfile(ctx, name, allowNew).then(reopenSettings).catch(error => {
+            ctx.addMessage({ role: 'system', content: `Profile switch failed: ${error.message}` });
+        });
+    };
+    ctx.settingsPanel.showSettingsPanel({
+        title: 'Switch config profile',
+        layout: 'page',
+        categories: [{ name: 'Config profiles', settings: [
+                    ...names.map(name => ({
+                        name: `switchProfile_${name}`,
+                        label: name === activeProfile() ? `${name} (active)` : name,
+                        value: builtinProfileEmulation(name) ? 'Built-in' : '',
+                        type: 'text',
+                        description: builtinProfileEmulation(name) ? 'Uses default settings and sign-ins with this emulation.' : undefined,
+                        onActivate: () => choose(name),
+                    })),
+                    {
+                        name: 'createConfigProfile', label: 'Use a new profile', value: '', type: 'text',
+                        description: 'Start with defaults. No existing profile files are changed.',
+                        onActivate: () => {
+                            if (!ctx.prompt.showPrompt) {
+                                ctx.addMessage({ role: 'system', content: 'Use /profile create <name> to start a new profile.' });
+                                return;
+                            }
+                            ctx.settingsPanel?.closeSettingsPanel?.();
+                            ctx.prompt.showPrompt({ title: 'New config profile', question: 'Profile name', placeholder: 'work' }, async (value) => {
+                                if (value === null) {
+                                    await reopenSettings();
+                                    return;
+                                }
+                                await choose(value, true);
+                            });
+                        },
+                    },
+                ] }],
+        onSettingChange: () => { },
+    });
+}
+/** A separate confirmation page keeps destructive reset out of ordinary row editing. */
+export function openFactoryResetConfirmation(ctx, onDone) {
+    if (!ctx.config.factoryReset || !ctx.settingsPanel) {
+        ctx.addMessage({ role: 'system', content: 'Factory reset needs the interactive settings panel.' });
+        return;
+    }
+    const path = ctx.config.locationLabel || '~/.ztc/config.json';
+    ctx.settingsPanel.showSettingsPanel({
+        title: 'Factory reset settings?',
+        layout: 'page',
+        categories: [{ name: 'Confirm reset', settings: [
+                    {
+                        name: 'keepSettings', label: 'Keep settings', value: '', type: 'text',
+                        onActivate: () => { if (onDone)
+                            return onDone();
+                        else
+                            ctx.settingsPanel?.closeSettingsPanel?.(); },
+                    },
+                    {
+                        name: 'confirmFactoryReset', label: 'Reset saved settings', value: '', type: 'text',
+                        description: `Remove ${path} and ${builtinProfileEmulation(activeProfile()) ? 'the shared default' : "this profile's"} ZRouter sign-in. `
+                            + 'This deletes the API keys, OpenAI-compatible endpoint, account registrations, voice keys and MCP servers saved there. '
+                            + 'Sessions and managed account directories stay on disk.',
+                        onActivate: () => {
+                            return (async () => {
+                                await ctx.config.factoryReset?.();
+                                ctx.reloadAgent();
+                                ctx.addMessage({ role: 'system', content: `Factory reset complete: ${path}` });
+                                if (onDone)
+                                    await onDone();
+                                else
+                                    ctx.settingsPanel?.closeSettingsPanel?.();
+                            })().catch(error => {
+                                ctx.addMessage({ role: 'system', content: `Factory reset failed: ${error.message}` });
+                            });
+                        },
+                    },
+                ] }],
+        onSettingChange: () => { },
+    });
+}