chati-dev 4.4.1 → 4.5.2

package/src/terminal/cli-registry.js

@@ -75,6 +75,20 @@ const PROVIDERS = {
     },
     adapter: adapters.codex,
   },
+  grok: {
+    name: 'grok',
+    command: 'grok',
+    baseArgs: [],
+    modelFlag: '-m',
+    stdinSupport: false,
+    hooksSupport: true,
+    mcpSupport: true,
+    contextFile: 'AGENTS.md',
+    modelMap: {
+      grok: 'grok-4.6',
+    },
+    adapter: adapters.grok,
+  },
 };
 
 // ---------------------------------------------------------------------------
@@ -117,14 +131,14 @@ export function loadEnabledProviders(projectDir) {
 
   // Filter out invalid provider names (typos in config.yaml)
   const validEnabled = enabled.filter(name => validNames.includes(name));
-  const validPrimary = validNames.includes(primary) ? primary : 'claude';
+  const validPrimary = validNames.includes(primary) ? primary : validEnabled[0] || null;
 
   return { primary: validPrimary, enabled: validEnabled };
 }
 
 /**
  * Resolve which provider should be used for a given agent.
- * Priority: agent_overrides > agent default > primary provider.
+ * Priority: agent_overrides > agent default > first enabled legacy fallback.
  *
  * @param {string} agent - Agent name
  * @param {string} projectDir - Project root directory
@@ -152,10 +166,11 @@ export function resolveProviderForAgent(agent, projectDir, agentModels) {
     }
   }
 
-  // Fallback to primary provider with its default light-tier model
-  const provider = PROVIDERS[primary];
+  // Legacy fallback only. Installation v2 routes from the signed task catalog.
+  const fallbackProvider = primary || enabled[0];
+  const provider = PROVIDERS[fallbackProvider];
   const defaultModel = provider ? Object.keys(provider.modelMap)[0] : 'sonnet';
-  return { provider: primary, model: defaultModel };
+  return { provider: fallbackProvider, model: defaultModel };
 }
 
 /**

package/src/terminal/prompt-builder.js

@@ -135,6 +135,8 @@ export function buildToolMeshSection(agent) {
  * @property {string[]} [writeScope]  - Override write scope
  * @property {string} [additionalContext] - Extra context (e.g. user answer to needs_input)
  * @property {string} [provider] - Active CLI provider (for overlay resolution)
+ * @property {string} [model] - Model selected by the installed provider profile
+ * @property {boolean} [strictProvider] - Runtime must not substitute a provider
  */
 
 /**
@@ -279,14 +281,14 @@ function buildPrismSection(config) {
 
 /**
  * Load the agent's full .md definition file.
- * For non-primary providers, resolves via overlay directory.
+ * For enabled providers, resolves via the provider-specific overlay directory.
  */
 function loadAgentDefinition(agent, projectDir, provider = null) {
   const relToFramework = AGENT_FILE_PATHS[agent];
   if (!relToFramework) return null;
 
   let fullPath;
-  if (provider && provider !== 'claude') {
+  if (provider) {
     fullPath = resolveOverlayPath(projectDir, relToFramework, provider);
   } else {
     fullPath = join(projectDir, resolveFrameworkDir(projectDir), relToFramework);

package/src/terminal/run-agent.js

@@ -94,6 +94,8 @@ async function main() {
       sessionState,
       additionalContext: args['additional-context'] || null,
       provider: args.provider || null,
+      model: args.model || null,
+      strictProvider: args['strict-provider'] === 'true',
     });
   } catch (err) {
     outputError(`Failed to build prompt: ${err.message}`);
@@ -127,6 +129,7 @@ async function main() {
       prompt: promptResult.prompt,
       workingDir: projectDir,
       timeout,
+      strictProvider: args['strict-provider'] === 'true',
     });
   } catch (err) {
     outputError(`Failed to spawn terminal: ${err.message}`);

package/src/terminal/run-parallel.js

@@ -45,6 +45,19 @@ function parseArgs(argv) {
   return args;
 }
 
+function createSpawnConfig({ agent, taskId, promptResult, projectDir, timeout, strictProvider }) {
+  return {
+    agent,
+    taskId,
+    model: promptResult.model,
+    provider: promptResult.provider,
+    prompt: promptResult.prompt,
+    workingDir: projectDir,
+    timeout,
+    strictProvider,
+  };
+}
+
 // ---------------------------------------------------------------------------
 // Main
 // ---------------------------------------------------------------------------
@@ -103,17 +116,14 @@ async function main() {
         previousAgent,
         sessionState,
         provider: args.provider || null,
+        model: args.model || null,
+        strictProvider: args['strict-provider'] === 'true',
       });
 
-      configs.push({
-        agent: agents[i],
-        taskId: taskIds[i],
-        model: promptResult.model,
-        provider: promptResult.provider,
-        prompt: promptResult.prompt,
-        workingDir: projectDir,
-        timeout,
-      });
+      configs.push(createSpawnConfig({
+        agent: agents[i], taskId: taskIds[i], promptResult, projectDir, timeout,
+        strictProvider: args['strict-provider'] === 'true',
+      }));
     } catch (err) {
       outputError(`Failed to build prompt for ${agents[i]}: ${err.message}`);
       process.exit(1);
@@ -268,6 +278,7 @@ async function sequentialFallback(configs, timeout, _spawnFn = spawnTerminal) {
       prompt: cfg.prompt,
       workingDir: cfg.workingDir,
       timeout: cfg.timeout || timeout,
+      strictProvider: cfg.strictProvider,
     });
 
     // Wait for the REAL process exit before spawning the next agent. The old
@@ -328,4 +339,4 @@ if (process.argv[1] === fileURLToPath(import.meta.url)) {
   });
 }
 
-export { parseArgs, determineNextAgent, sequentialFallback };
+export { parseArgs, createSpawnConfig, determineNextAgent, sequentialFallback };

package/src/terminal/spawner.js

@@ -107,7 +107,8 @@ export function cleanParentEnv(env) {
  * @property {string} agent           - Agent name (e.g. "architect")
  * @property {string} taskId          - Task identifier
  * @property {string} [model]         - LLM model tier name (e.g. opus, pro, codex, claude-sonnet)
- * @property {string} [provider]      - CLI provider name (claude, gemini, codex)
+ * @property {string} [provider]      - CLI provider name (claude, gemini, codex, grok)
+ * @property {boolean} [strictProvider] - Reject a missing provider rather than using the legacy fallback
  * @property {string} [prompt]        - Full prompt string (from prompt-builder, piped via stdin)
  * @property {object} [contextPayload] - Context to inject via env var
  * @property {string[]} [writeScope]   - Override write scope
@@ -181,6 +182,11 @@ export function buildSpawnCommand(config) {
     args = adapterResult.args;
     prompt = adapterResult.stdinPrompt;
   } catch (err) {
+    if (config.strictProvider) {
+      const failure = new Error(`Selected provider "${providerName}" is unavailable: ${err.message}`);
+      failure.code = 'SELECTED_PROVIDER_UNAVAILABLE';
+      throw failure;
+    }
     // Fallback to claude if provider resolution fails (backwards compatibility)
     providerFallback = {
       requested: providerName,

package/src/terminal/team-task-list.js

@@ -10,7 +10,7 @@
 
 import { existsSync, readFileSync, writeFileSync, mkdirSync, readdirSync, realpathSync } from 'fs';
 import { join, dirname, resolve, relative } from 'path';
-import yaml from 'js-yaml';
+import * as yaml from 'js-yaml';
 import { withLock } from '../utils/file-lock.js';
 
 // ---------------------------------------------------------------------------

package/src/upgrade/checker.js

@@ -1,7 +1,7 @@
 import { readFileSync, writeFileSync, existsSync } from 'fs';
 import { join } from 'path';
 import { resolveFrameworkDir } from '../utils/framework-dir.js';
-import yaml from 'js-yaml';
+import * as yaml from 'js-yaml';
 import semver from 'semver';
 
 /**

package/src/upgrade/migrator.js

@@ -2,7 +2,7 @@ import { readFileSync, writeFileSync, existsSync, mkdirSync, readdirSync, rmSync
 import { dirname, join } from 'path';
 import { fileURLToPath } from 'url';
 import { resolveFrameworkDir } from '../utils/framework-dir.js';
-import yaml from 'js-yaml';
+import * as yaml from 'js-yaml';
 import semver from 'semver';
 
 const __dirname = dirname(fileURLToPath(import.meta.url));

package/src/utils/config-parser.js

@@ -1,7 +1,7 @@
 /**
  * @fileoverview Shared YAML config parser for provider configuration.
  *
- * Extracts provider enabled/primary status and agent overrides from
+ * Extracts enabled providers and legacy primary status from
  * config.yaml using lightweight regex-based parsing. Used by
  * cli-registry.js, context-file-generator.js, and health/engine.js.
  */
@@ -23,9 +23,9 @@ export function parseProviderConfig(projectDir) {
   }
 
   const raw = readFileSync(configPath, 'utf-8');
-  const providers = ['claude', 'gemini', 'codex'];
+  const providers = ['claude', 'gemini', 'codex', 'grok'];
   const enabled = [];
-  let primary = 'claude';
+  let primary = null;
 
   for (const name of providers) {
     const enabledMatch = raw.match(new RegExp(`${name}:[\\s\\S]*?enabled:\\s*(true|false)`, 'm'));
@@ -38,11 +38,6 @@ export function parseProviderConfig(projectDir) {
     }
   }
 
-  // Claude is always enabled as fallback
-  if (!enabled.includes('claude')) {
-    enabled.unshift('claude');
-  }
-
   return { primary, enabled, raw };
 }
 

package/src/wizard/i18n.js

@@ -1,7 +1,7 @@
 import { readFileSync, existsSync } from 'fs';
 import { join, dirname } from 'path';
 import { fileURLToPath } from 'url';
-import yaml from 'js-yaml';
+import * as yaml from 'js-yaml';
 import { resolveFrameworkDir } from '../utils/framework-dir.js';
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
@@ -30,13 +30,19 @@ const FALLBACK_EN = {
     ide_selection_title: 'Select your IDEs / CLIs (multiple allowed):',
     provider_selection_title: 'Which AI providers will you use?',
     editor_selection_title: 'Which editor IDEs should get rules files? (optional)',
-    primary_provider_title: 'Which is your primary CLI provider?',
-    primary_provider_label: 'Primary Provider',
+    installation_mode_title: 'Select the installation mode',
+    installation_mode_open: 'Open',
+    installation_mode_open_hint: 'Public framework without mandatory company integrations',
+    installation_mode_internal: 'Internal',
+    installation_mode_internal_hint: 'Requires an authorized license and enables ClickUp tracking plus internal policies',
+    installation_mode_label: 'Installation mode',
+    model_routing_label: 'Model routing',
+    model_routing_automatic: 'Automatic per task across all enabled models',
     providers_label: 'Providers',
     quick_start_switch_hint: 'Switch CLIs anytime — your session continues from where you left off',
     created_overlays: 'Created provider overlay directories',
     will_install: 'Will install:',
-    agents_count: 'Specialized agent definitions across DISCOVER, PLAN, BUILD, DEPLOY phases',
+    agents_count: 'Specialized discovery and planning agents with RAIL execution and release lanes',
     workflows_count: '6 workflow blueprints',
     templates_count: '6 templates (PRD, Brownfield PRD, Architecture, Task, QA Gate, Quick Brief)',
     constitution: 'Constitution (25 Articles + Preamble)',

package/src/wizard/index.js

@@ -1,19 +1,22 @@
 import * as p from '@clack/prompts';
-import { readFileSync } from 'fs';
+import { existsSync, readFileSync } from 'fs';
 import { join, dirname, basename } from 'path';
 import { fileURLToPath } from 'url';
 import { logBanner } from '../utils/logger.js';
-import { stepLanguage, stepProjectType, stepProviderSelection, stepEditorSelection, stepPrimaryProvider, stepConfirmation, stepTermsOfUse } from './questions.js';
+import { stepLanguage, stepProjectType, stepProviderSelection, stepEditorSelection, stepModelSelection, stepInstallationMode, stepConfirmation, stepTermsOfUse } from './questions.js';
 import { createSpinner, showStep, showValidation, showQuickStart } from './feedback.js';
 import { installFramework } from '../installer/core.js';
+import { INSTALLATION_ARTIFACT_PATH, dryRunV2, installV2, reconfigureV2 } from '../installer-v2/index.js';
+import { buildWizardV2InstallationInput } from '../installer-v2/wizard-installation.js';
+import { resolveCapabilityCatalog, verifySignedCapabilityCatalog } from '../installer-v2/catalog-client.js';
 import { validateInstallation } from '../installer/validator.js';
 import { initCollector, track as telemetryTrack, flush as telemetryFlush } from '../telemetry/collector.js';
 import { sendEvents } from '../telemetry/sender.js';
 import { getTelemetryConfig } from '../telemetry/config.js';
 import { t } from './i18n.js';
-import { getLicenseKey, activateLicense } from '../license/client.js';
+import { getLicenseKey, activateLicense, requireLicenseEntitlement } from '../license/client.js';
 import { DEFAULT_MCPS } from '../config/mcp-configs.js';
-import { IDE_CONFIGS, IDE_TO_PROVIDER } from '../config/ide-configs.js';
+import { IDE_CONFIGS } from '../config/ide-configs.js';
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
 const VERSION = JSON.parse(readFileSync(join(__dirname, '..', '..', 'package.json'), 'utf-8')).version;
@@ -66,14 +69,28 @@ export async function runWizard(targetDir, options = {}) {
   // Step 3a: Provider Selection (which AI providers to use)
   const selectedProviders = options.providers || await stepProviderSelection();
 
-  // Step 3b: Primary provider (only if multiple)
-  const primaryProvider = options.llmProvider || await stepPrimaryProvider(selectedProviders);
+  // Step 3b: Enable the full signed lineup for every selected provider. Runtime
+  // routing selects the right model per task instead of pinning one at install.
+  if (options.capabilityCatalog) {
+    throw Object.assign(new Error('unsigned capabilityCatalog injection is forbidden; provide signedCapabilityCatalogEnvelope'), { code: 'UNSIGNED_CATALOG_FORBIDDEN' });
+  }
+  const catalogResolution = options.signedCapabilityCatalogEnvelope
+    ? { source: 'provided-signed', catalog: verifySignedCapabilityCatalog(options.signedCapabilityCatalogEnvelope, { publicKeyPem: options.catalogPublicKeyPem }) }
+    : await resolveCapabilityCatalog({ projectDir: targetDir, catalogUrl: options.catalogUrl, fetchImpl: options.catalogFetch });
+  const modelSelections = options.modelSelections || await stepModelSelection(selectedProviders, catalogResolution.catalog);
+
+  // Step 3c: Internal mode is a server-authorized entitlement. It enables the
+  // internal policy bundle, including mandatory ClickUp tracking.
+  const installationMode = options.installationMode || await stepInstallationMode();
+  if (installationMode === 'internal') {
+    await requireLicenseEntitlement('internal', { validate: options.licenseValidator });
+  }
 
-  // Step 3c: Editor Selection (which editor IDEs get rules files)
+  // Step 3e: Editor Selection (which editor IDEs get rules files)
   const selectedEditors = options.editors || await stepEditorSelection();
 
   // Combine providers + editors into selectedIDEs for backward compatibility
-  const providerToIDE = { claude: 'claude-code', gemini: 'gemini-cli', codex: 'codex-cli' };
+  const providerToIDE = { claude: 'claude-code', gemini: 'gemini-cli', codex: 'codex-cli', grok: 'grok-cli' };
   const selectedIDEs = options.ides || [
     ...selectedProviders.map(p => providerToIDE[p]).filter(Boolean),
     ...selectedEditors,
@@ -90,13 +107,28 @@ export async function runWizard(targetDir, options = {}) {
     projectName,
     projectType,
     language,
-    llmProvider: primaryProvider,
     allProviders: cliProviders,
     selectedIDEs,
     selectedMCPs,
+    installationMode,
+    modelSelections,
     targetDir,
     version: VERSION,
   };
+  const v2InstallationInput = buildWizardV2InstallationInput({
+    projectName,
+    selectedProviders: cliProviders,
+    modelSelections,
+    capabilityCatalog: catalogResolution.catalog,
+    installationMode,
+  });
+  // Validate the complete v2 material and refuse a repeated init before the
+  // legacy installer writes anything. Reconfiguration uses its own backup and
+  // atomic replacement path below.
+  dryRunV2(v2InstallationInput, { projectDir: targetDir });
+  if (existsSync(join(targetDir, INSTALLATION_ARTIFACT_PATH)) && options.reconfigure !== true) {
+    throw Object.assign(new Error('a v2 installation already exists; use --reconfigure to replace it safely'), { code: 'INSTALLATION_ALREADY_EXISTS' });
+  }
 
   await stepConfirmation(config);
 
@@ -104,8 +136,7 @@ export async function runWizard(targetDir, options = {}) {
   config.telemetryEnabled = options.telemetry !== undefined ? options.telemetry : true;
 
   // Installation + Validation
-  const primaryIDE = selectedIDEs.find(ide => IDE_TO_PROVIDER[ide] === primaryProvider) || selectedIDEs[0];
-  const primaryIDEName = IDE_CONFIGS[primaryIDE]?.name || primaryIDE;
+  const selectedCLIIDEs = selectedIDEs.filter(ide => IDE_CONFIGS[ide]?.group === 'cli');
 
   const installStart = Date.now();
 
@@ -115,6 +146,8 @@ export async function runWizard(targetDir, options = {}) {
 
   try {
     await installFramework(config);
+    if (options.reconfigure === true) reconfigureV2(v2InstallationInput, { projectDir: targetDir });
+    else installV2(v2InstallationInput, { projectDir: targetDir });
     installSpinner.stop();
 
     showStep(t('installer.created_chati'));
@@ -126,8 +159,9 @@ export async function runWizard(targetDir, options = {}) {
       'gemini-cli': 'Created .gemini/commands/ (TOML command)',
       'codex-cli': 'Created .agents/skills/chati/ (Codex skill)',
     };
-    const commandStep = commandStepMap[primaryIDE] || t('installer.created_commands');
-    showStep(commandStep);
+    for (const cliIDE of selectedCLIIDEs) {
+      showStep(commandStepMap[cliIDE] || t('installer.created_commands'));
+    }
 
     showStep(t('installer.installed_constitution'));
     showStep(t('installer.created_session'));
@@ -176,10 +210,9 @@ export async function runWizard(targetDir, options = {}) {
     const invokeCmdMap = {
       'codex-cli': '$chati',
     };
-    const invokeCmd = invokeCmdMap[primaryIDE] || '/chati';
     const quickStartSteps = [
-      `${t('installer.quick_start_1')} (${primaryIDEName})`,
-      `Type: ${invokeCmd}`,
+      t('installer.quick_start_1'),
+      ...selectedCLIIDEs.map((cliIDE) => `${IDE_CONFIGS[cliIDE]?.name || cliIDE}: ${invokeCmdMap[cliIDE] || '/chati'}`),
       t('installer.quick_start_3'),
     ];
 
@@ -197,7 +230,6 @@ export async function runWizard(targetDir, options = {}) {
       editors: selectedEditors,
       projectType,
       language,
-      primaryProvider,
       installDuration: Date.now() - installStart,
     });
     const installEvents = telemetryFlush();

package/src/wizard/questions.js

@@ -5,6 +5,7 @@ import { showSummary, showChecklist } from './feedback.js';
 import { brand, dim, success } from '../utils/colors.js';
 import { isProviderAvailable } from '../terminal/cli-registry.js';
 import { IDE_CONFIGS, IDE_TO_PROVIDER } from '../config/ide-configs.js';
+import { supportedV2WizardProviders, wizardModelSuggestions } from '../installer-v2/wizard-installation.js';
 
 /**
  * Step 1: Language Selection (always in English)
@@ -66,6 +67,7 @@ const PROVIDER_DISPLAY_NAMES = {
   claude: 'Claude (Anthropic)',
   gemini: 'Gemini (Google)',
   codex: 'Codex (OpenAI)',
+  grok: 'Grok (xAI)',
 };
 
 /**
@@ -75,7 +77,7 @@ const PROVIDER_DISPLAY_NAMES = {
  * Returns an array of provider names (e.g. ['claude', 'gemini']).
  */
 export async function stepProviderSelection() {
-  const cliIDEs = Object.entries(IDE_CONFIGS).filter(([, c]) => c.group === 'cli');
+  const cliIDEs = Object.entries(IDE_CONFIGS).filter(([key, c]) => c.group === 'cli' && supportedV2WizardProviders.includes(IDE_TO_PROVIDER[key]));
   const options = [];
 
   for (const [key, config] of cliIDEs) {
@@ -91,7 +93,7 @@ export async function stepProviderSelection() {
     const providerName = PROVIDER_DISPLAY_NAMES[provider] || config.name;
     options.push({
       value: provider,
-      label: `${providerName}${config.recommended ? ' (Recommended)' : ''}${suffix}`,
+      label: `${providerName}${suffix}`,
       hint: config.description,
     });
   }
@@ -110,6 +112,30 @@ export async function stepProviderSelection() {
   return selected;
 }
 
+/**
+ * Selects the operational policy profile. Focus AI internal projects require
+ * ClickUp tracking; standard projects do not gain that external dependency.
+ */
+export async function stepInstallationMode() {
+  const mode = await p.select({
+    message: t('installer.installation_mode_title'),
+    options: [
+      { value: 'open', label: t('installer.installation_mode_open'), hint: t('installer.installation_mode_open_hint') },
+      { value: 'internal', label: t('installer.installation_mode_internal'), hint: t('installer.installation_mode_internal_hint') },
+    ],
+    initialValue: 'open',
+  });
+  if (p.isCancel(mode)) {
+    p.cancel('Installation cancelled.');
+    process.exit(0);
+  }
+  return mode;
+}
+
+// Backward-compatible programmatic alias. The interactive wizard no longer
+// exposes an abstract execution profile to users.
+export const stepExecutionProfile = stepInstallationMode;
+
 /**
  * Step 3b: Editor Selection (multi-select, optional)
  *
@@ -204,44 +230,36 @@ export async function stepIDESelection() {
 }
 
 /**
- * Step 3b: Primary CLI Provider Selection
- *
- * Only shown when the user selected multiple CLI-based IDEs.
- * Determines which provider's adapted files go in chati.dev/ (main).
+ * Enables every catalog model for each selected provider. Runtime routing
+ * chooses a model per task, so installation never collapses a provider to one
+ * supposedly universal "recommended" model.
  */
-export async function stepPrimaryProvider(cliProviders) {
-  if (cliProviders.length <= 1) return cliProviders[0] || 'claude';
-
-  const primary = await p.select({
-    message: t('installer.primary_provider_title'),
-    options: cliProviders.map(prov => ({
-      value: prov,
-      label: PROVIDER_DISPLAY_NAMES[prov] || prov,
-    })),
-  });
-
-  if (p.isCancel(primary)) {
-    p.cancel('Installation cancelled.');
-    process.exit(0);
+export async function stepModelSelection(providers, capabilityCatalog) {
+  const selections = {};
+  const summary = [];
+
+  for (const provider of providers) {
+    const models = wizardModelSuggestions(provider, capabilityCatalog);
+    selections[provider] = [...models];
+    summary.push(`${PROVIDER_DISPLAY_NAMES[provider] || provider}: ${models.join(', ')}`);
   }
 
-  return primary;
+  p.note(summary.join('\n'), t('installer.model_routing_label'));
+
+  return selections;
 }
 
 /**
  * Step 4: Confirmation
  */
 export async function stepConfirmation(config) {
-  const { projectName, projectType, language, llmProvider, selectedMCPs, selectedIDEs, allProviders } = config;
+  const { projectName, projectType, language, selectedMCPs, selectedIDEs, allProviders, installationMode } = config;
 
   const langName = SUPPORTED_LANGUAGES.find(l => l.value === language)?.label || language;
 
-  // Show all providers with primary indicator
-  const providers = allProviders || [llmProvider || 'claude'];
-  const providersDisplay = providers.map(prov => {
-    const name = PROVIDER_DISPLAY_NAMES[prov] || prov;
-    return prov === llmProvider ? `${name} (Primary)` : name;
-  }).join(', ');
+  // Show all enabled providers symmetrically.
+  const providers = allProviders || [];
+  const providersDisplay = providers.map(prov => PROVIDER_DISPLAY_NAMES[prov] || prov).join(', ');
 
   // Separate editors from CLI IDEs for display
   const editorIDEs = (selectedIDEs || []).filter(id => IDE_CONFIGS[id]?.group === 'editor');
@@ -256,6 +274,10 @@ export async function stepConfirmation(config) {
     [t('installer.project_label')]: `${projectName} (${projectType === 'greenfield' ? 'Greenfield' : 'Brownfield'})`,
     [t('installer.language_label')]: langName,
     [t('installer.providers_label')]: providersDisplay,
+    [t('installer.model_routing_label')]: t('installer.model_routing_automatic'),
+    [t('installer.installation_mode_label')]: installationMode === 'internal'
+      ? t('installer.installation_mode_internal')
+      : t('installer.installation_mode_open'),
   };
 
   // Only show editor IDEs line if any were selected