chati-dev 4.5.4 → 4.5.6

package/src/orchestrator/cli.js

@@ -583,6 +583,19 @@ export function buildParallelSpawnCommand(agents, projectDir, previousAgent, pro
   return parts.join(' ');
 }
 
+export function buildRoutedParallelSpawnCommands(agents, projectDir, previousAgent, timeout = 900000) {
+  return agents.map((agent) => {
+    const modelInfo = resolveAgentModel(agent, projectDir);
+    return Object.freeze({
+      agent,
+      provider: modelInfo.provider,
+      model: modelInfo.model,
+      reasoning_configuration: modelInfo.reasoning_configuration,
+      command: buildSpawnCommand(agent, projectDir, previousAgent, modelInfo.provider, timeout, modelInfo.model, modelInfo.source === 'installation-v2'),
+    });
+  });
+}
+
 /**
  * Model map — canonical model tier per agent.
  * Matches framework/hooks/model-governance.js AGENT_MODELS.
@@ -748,7 +761,7 @@ async function handleNext(projectDir) {
   // Centralized session lock update: applies to ALL return paths.
   // Activates lock when an agent is returned, deactivates on completion.
   if (result && result.agent && result.action !== 'error' && result.action !== 'setup') {
-    const activating = ['activate_interactive', 'spawn_autonomous', 'spawn_team', 'spawn_parallel'];
+    const activating = ['activate_interactive', 'spawn_routed_interactive', 'spawn_autonomous', 'spawn_team', 'spawn_parallel'];
     if (activating.includes(result.action)) {
       try {
         writeSessionLock(projectDir, result.agent, {
@@ -830,20 +843,18 @@ async function _handleNextInner(projectDir) {
         };
       }
 
+      const modelInfo = resolveAgentModel(agent, projectDir);
       return {
-        action: isInteractive ? 'activate_interactive' : 'spawn_autonomous',
+        action: isInteractive ? 'spawn_routed_interactive' : 'spawn_autonomous',
         agent,
         agent_file: agentFile,
         phase: agentDef?.phase || session.mode,
-        spawn_command: isInteractive ? null : (() => {
-          const modelInfo = resolveAgentModel(agent, projectDir);
-          return buildSpawnCommand(agent, projectDir, session.last_handoff || 'none', modelInfo.provider, 600000, modelInfo.model, modelInfo.source === 'installation-v2');
-        })(),
+        spawn_command: buildSpawnCommand(agent, projectDir, session.last_handoff || 'none', modelInfo.provider, 600000, modelInfo.model, modelInfo.source === 'installation-v2'),
         parallel_spawn_command: null,
         parallel_agents: [],
         handoff_status: { valid: true, missing: [], warnings: ['Resuming in-progress agent'] },
         gate_status: { canAdvance: true, reason: 'Agent already in progress' },
-        model_info: resolveAgentModel(agent, projectDir),
+        model_info: modelInfo,
         context_bracket: estimateContextBracket(completedAgents.length, AGENT_PIPELINE.length),
         pipeline_progress: getPipelineProgress(pipelineState),
         session: { language: session.language, project_type: session.project_type || session.project?.type, execution_mode: session.execution_mode, user_level: session.user_level || 'auto' },
@@ -861,17 +872,18 @@ async function _handleNextInner(projectDir) {
     const firstAgent = projectType === 'brownfield' ? 'brownfield-wu' : 'greenfield-wu';
     const agentFile = getAgentFile(firstAgent, projectDir) || null;
 
+    const modelInfo = resolveAgentModel(firstAgent, projectDir);
     return {
-      action: 'activate_interactive',
+      action: 'spawn_routed_interactive',
       agent: firstAgent,
       agent_file: agentFile,
       phase: 'discover',
-      spawn_command: null,
+      spawn_command: buildSpawnCommand(firstAgent, projectDir, 'none', modelInfo.provider, 600000, modelInfo.model, modelInfo.source === 'installation-v2'),
       parallel_spawn_command: null,
       parallel_agents: [],
       handoff_status: { valid: true, missing: [], warnings: [] },
       gate_status: { canAdvance: true, reason: 'First agent in pipeline' },
-      model_info: resolveAgentModel(firstAgent, projectDir),
+      model_info: modelInfo,
       context_bracket: estimateContextBracket(0, AGENT_PIPELINE.length),
       pipeline_progress: getPipelineProgress(pipelineState),
       session: { language: session.language, project_type: projectType, execution_mode: session.execution_mode, user_level: session.user_level || 'auto' },
@@ -932,7 +944,7 @@ async function _handleNextInner(projectDir) {
   const modelInfo = resolveAgentModel(nextAgent, projectDir);
 
   // Check for parallel group — with Agent Teams override (Article XXI)
-  let action, spawnCommand = null, parallelSpawnCommand = null, parallelAgents = [];
+  let action, spawnCommand = null, parallelSpawnCommand = null, parallelSpawnCommands = [], parallelAgents = [];
   let teamData = null;
   const teamsEnabled = isAgentTeamsEnabled(projectDir);
 
@@ -948,7 +960,11 @@ async function _handleNextInner(projectDir) {
     } else {
       action = 'spawn_parallel';
       parallelAgents = nextInfo.group;
-      parallelSpawnCommand = buildParallelSpawnCommand(nextInfo.group, projectDir, lastAgent, modelInfo.provider, 900000, modelInfo.model, modelInfo.source === 'installation-v2');
+      if (modelInfo.source === 'installation-v2') {
+        parallelSpawnCommands = buildRoutedParallelSpawnCommands(nextInfo.group, projectDir, lastAgent);
+      } else {
+        parallelSpawnCommand = buildParallelSpawnCommand(nextInfo.group, projectDir, lastAgent, modelInfo.provider, 900000, modelInfo.model, false);
+      }
     }
   } else if (nextAgent === 'dev' && teamsEnabled) {
     // Build Team auto-spawn: dev + qa-implementation are NOT parallel in the
@@ -962,7 +978,8 @@ async function _handleNextInner(projectDir) {
     parallelAgents = teamConfig.members;
     teamData = { team_id: teamId, team_type: 'build', members: teamConfig.members };
   } else if (isInteractive) {
-    action = 'activate_interactive';
+    action = 'spawn_routed_interactive';
+    spawnCommand = buildSpawnCommand(nextAgent, projectDir, lastAgent, modelInfo.provider, 600000, modelInfo.model, modelInfo.source === 'installation-v2');
   } else {
     action = 'spawn_autonomous';
     spawnCommand = buildSpawnCommand(nextAgent, projectDir, lastAgent, modelInfo.provider, 600000, modelInfo.model, modelInfo.source === 'installation-v2');
@@ -1000,6 +1017,7 @@ async function _handleNextInner(projectDir) {
     phase: agentDef?.phase || session.mode,
     spawn_command: spawnCommand,
     parallel_spawn_command: parallelSpawnCommand,
+    parallel_spawn_commands: parallelSpawnCommands,
     parallel_agents: parallelAgents,
     handoff_status: handoffStatus,
     gate_status: gateStatus,
@@ -2418,16 +2436,13 @@ async function handleProviders(projectDir) {
     agentModels[agentDef.name] = resolveAgentModel(agentDef.name, projectDir);
   }
 
-  let primaryProvider = 'claude';
-  const configPath = join(projectDir, resolveFrameworkDir(projectDir), 'config.yaml');
-  if (existsSync(configPath)) {
-    const raw = readFileSync(configPath, 'utf-8');
-    const providerMatch = raw.match(/primary_provider:\s*["']?(\w+)/);
-    if (providerMatch) primaryProvider = providerMatch[1].toLowerCase();
-  }
+  const artifact = loadRuntimeInstallationV2(projectDir);
+  const enabledProviders = artifact
+    ? artifact.installation.enabled_providers.map(({ provider_id, harness_id }) => ({ provider_id, harness_id }))
+    : [...new Set(Object.values(agentModels).map(({ provider }) => provider).filter(Boolean))].map((harness_id) => ({ harness_id }));
 
   return {
-    primary_provider: primaryProvider,
+    enabled_providers: enabledProviders,
     agent_models: agentModels,
   };
 }

package/src/orchestrator/clickup-projection.js

@@ -61,14 +61,8 @@ export function enqueueClickUpProjectionFromState({ projectDir, handoff, records
     ...(completion?.reviews || []),
     ...(completion?.acceptance_evidence_refs || []),
   ]);
-  const tracking = new TrackingClickUp({
-    outbox_path: join(projectDir, '.chati/v2/tracking/clickup-outbox.json'),
-    project_evolution_dir: join(projectDir, '.chati/v2/project-evolution'),
-    clock, verify_completion: (candidate) => completionIsCanonical(records, candidate),
-    verify_reference: (ref) => refs.has(ref),
-    resolve_reference: (ref, type) => type === 'handoff'
-      ? { phase: 'rail-execution', handoff_id: handoff.handoff_id }
-      : { task_state: taskState(records, handoff.handoff_id, task_id), blockers: journalBlockers(records, handoff.handoff_id, task_id) },
+  const tracking = createClickUpTrackingFromState({
+    projectDir, handoff, records, task_id, clock, extra_verified_refs: [...refs],
   });
   const projection = tracking.enqueue({
     projection_id: `clickup-${sha256({ handoff_id: handoff.handoff_id, task_id, attempt_id, operation, payload }).slice(0, 24)}`,
@@ -82,3 +76,26 @@ export function enqueueClickUpProjectionFromState({ projectDir, handoff, records
   }
   return projection;
 }
+
+export function createClickUpTrackingFromState({ projectDir, handoff, records, task_id, clock = () => new Date(), extra_verified_refs = [] } = {}) {
+  const task = handoff.tasks.find((item) => item.task_id === task_id);
+  if (!task) throw Object.assign(new Error(`task ${task_id} is absent from handoff`), { code: 'TASK_NOT_FOUND' });
+  const handoff_ref = `rail-handoff://${handoff.handoff_id}/${handoff.seal.manifest_digest}`;
+  const journal_ref = `rail-journal://sha256/${sha256(records)}`;
+  const derivedDecisions = journalDecisions(records, handoff.handoff_id, task_id);
+  const refs = new Set([
+    handoff_ref,
+    journal_ref,
+    ...derivedDecisions.flatMap((item) => [item.decision_ref, item.review_ref]),
+    ...extra_verified_refs,
+  ]);
+  return new TrackingClickUp({
+    outbox_path: join(projectDir, '.chati/v2/tracking/clickup-outbox.json'),
+    project_evolution_dir: join(projectDir, '.chati/v2/project-evolution'),
+    clock, verify_completion: (candidate) => completionIsCanonical(records, candidate),
+    verify_reference: (ref) => refs.has(ref),
+    resolve_reference: (ref, type) => type === 'handoff'
+      ? { phase: 'rail-execution', handoff_id: handoff.handoff_id }
+      : { task_state: taskState(records, handoff.handoff_id, task_id), blockers: journalBlockers(records, handoff.handoff_id, task_id) },
+  });
+}

package/src/orchestrator/clickup-runtime.js

@@ -1,5 +1,8 @@
+import { existsSync, mkdirSync, readFileSync, renameSync, writeFileSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { sha256 } from '@chati/core';
 import { createProjectRailEngine, loadRailHandoff } from './rail-runtime.js';
-import { enqueueClickUpProjectionFromState } from './clickup-projection.js';
+import { createClickUpTrackingFromState, enqueueClickUpProjectionFromState } from './clickup-projection.js';
 
 /** Enqueues a durable local ClickUp projection. It never sends to ClickUp. */
 export function enqueueClickUpProjection({ projectDir, handoff_id, task_id, attempt_id, operation = 'update', payload, completion, decisions, clock = () => new Date() } = {}) {
@@ -11,3 +14,88 @@ export function enqueueClickUpProjection({ projectDir, handoff_id, task_id, atte
 }
 
 export { enqueueClickUpProjectionFromState } from './clickup-projection.js';
+
+export function listPendingClickUpProjections({ projectDir } = {}) {
+  const path = join(projectDir, '.chati/v2/tracking/clickup-outbox.json');
+  if (!existsSync(path)) return Object.freeze([]);
+  const outbox = JSON.parse(readFileSync(path, 'utf8'));
+  return Object.freeze((outbox.projections || [])
+    .filter((projection) => ['pending', 'retryable_failure', 'sent_unconfirmed'].includes(projection.delivery_state))
+    .map((projection) => Object.freeze({
+      projection_id: projection.projection_id,
+      clickup_ref: projection.clickup_ref,
+      operation: projection.operation,
+      payload: projection.payload,
+      idempotency_key: projection.idempotency_key,
+    })));
+}
+
+const SENSITIVE_RECEIPT_KEY = /(authorization|cookie|credential|password|secret|token)/i;
+
+export function sanitizeClickUpReceipt(value, depth = 0) {
+  if (depth > 8) return '[truncated]';
+  if (Array.isArray(value)) return value.slice(0, 100).map((item) => sanitizeClickUpReceipt(item, depth + 1));
+  if (!value || typeof value !== 'object') return value;
+  return Object.fromEntries(Object.entries(value)
+    .filter(([key]) => !SENSITIVE_RECEIPT_KEY.test(key))
+    .map(([key, item]) => [key, sanitizeClickUpReceipt(item, depth + 1)]));
+}
+
+function hasRemoteReceiptIdentifier(value, depth = 0) {
+  if (depth > 8 || !value || typeof value !== 'object') return false;
+  if (Array.isArray(value)) return value.some((item) => hasRemoteReceiptIdentifier(item, depth + 1));
+  return Object.entries(value).some(([key, item]) =>
+    (/^(id|task_id|comment_id|task_url|url)$/i.test(key) && typeof item === 'string' && item.trim() !== '')
+    || hasRemoteReceiptIdentifier(item, depth + 1));
+}
+
+export function clickUpReceiptConfirmsSuccess(receipt) {
+  if (!receipt || typeof receipt !== 'object' || Array.isArray(receipt)) return false;
+  if (receipt.isError === true || receipt.success === false) return false;
+  if (typeof receipt.status === 'string' && /^(failed|error|unauthorized)$/i.test(receipt.status)) return false;
+  return receipt.success === true
+    || (typeof receipt.status === 'string' && /^(success|ok|completed)$/i.test(receipt.status))
+    || hasRemoteReceiptIdentifier(receipt);
+}
+
+export function acknowledgeClickUpProjection({ projectDir, handoff_id, projection_id, receipt, clock = () => new Date() } = {}) {
+  if (!receipt || typeof receipt !== 'object' || Array.isArray(receipt)) throw Object.assign(new Error('receipt must be an object'), { code: 'INVALID_CLICKUP_RECEIPT' });
+  const { handoff } = loadRailHandoff({ projectDir, handoff_id });
+  const outboxPath = join(projectDir, '.chati/v2/tracking/clickup-outbox.json');
+  const outbox = JSON.parse(readFileSync(outboxPath, 'utf8'));
+  const projection = outbox.projections?.find((item) => item.projection_id === projection_id);
+  if (!projection) throw Object.assign(new Error(`projection ${projection_id} does not exist`), { code: 'PROJECTION_NOT_FOUND' });
+  const records = createProjectRailEngine({ projectDir, clock }).records;
+  if (projection.delivery_state === 'confirmed' && projection.receipt_ref) {
+    const tracking = createClickUpTrackingFromState({
+      projectDir, handoff, records, task_id: projection.task_id, clock, extra_verified_refs: [projection.receipt_ref],
+    });
+    return tracking.confirmExternalDelivery({ projection_id, receipt_ref: projection.receipt_ref });
+  }
+  if (!clickUpReceiptConfirmsSuccess(receipt)) {
+    throw Object.assign(new Error('receipt does not prove a successful ClickUp operation'), { code: 'CLICKUP_RECEIPT_UNCONFIRMED' });
+  }
+  const observed = clock();
+  const receivedAt = (observed instanceof Date ? observed : new Date(observed)).toISOString();
+  const safeReceipt = sanitizeClickUpReceipt(receipt);
+  const receiptMaterial = { schema_version: 1, projection_id, received_at: receivedAt, response: safeReceipt };
+  if (JSON.stringify(receiptMaterial).length > 64 * 1024) {
+    throw Object.assign(new Error('receipt exceeds 64 KiB after sanitization'), { code: 'CLICKUP_RECEIPT_TOO_LARGE' });
+  }
+  const digest = sha256(receiptMaterial);
+  const receiptPath = join(projectDir, '.chati/v2/tracking/receipts', `${digest}.json`);
+  mkdirSync(dirname(receiptPath), { recursive: true, mode: 0o700 });
+  const serialized = `${JSON.stringify(receiptMaterial, null, 2)}\n`;
+  if (!existsSync(receiptPath)) {
+    const temporary = `${receiptPath}.${process.pid}.tmp`;
+    writeFileSync(temporary, serialized, { encoding: 'utf8', flag: 'wx', mode: 0o600 });
+    renameSync(temporary, receiptPath);
+  } else if (readFileSync(receiptPath, 'utf8') !== serialized) {
+    throw Object.assign(new Error('receipt digest collision'), { code: 'CLICKUP_RECEIPT_CONFLICT' });
+  }
+  const receiptRef = `clickup-receipt://sha256/${digest}`;
+  const tracking = createClickUpTrackingFromState({
+    projectDir, handoff, records, task_id: projection.task_id, clock, extra_verified_refs: [receiptRef],
+  });
+  return tracking.confirmExternalDelivery({ projection_id, receipt_ref: receiptRef });
+}

package/src/orchestrator/planning-runtime.js

@@ -87,8 +87,7 @@ export function compilePlanningHandoff({ projectDir, clock = () => new Date() }
   };
   if (sources.ux_path) source_artifacts.ux_ref = immutableFileRef(projectDir, sources.ux_path, 'PLANNING_SOURCE_ARTIFACTS_REQUIRED');
   const ids = new Set();
-  const clickupRequired = installation.installation.profile === 'focus-ai-internal'
-    && installation.installation.external_integrations?.clickup === 'required';
+  const clickupRequired = installation.installation.external_integrations?.clickup === 'required';
   const tasks = planning.tasks.map((task) => {
     if (!task || typeof task !== 'object' || typeof task.id !== 'string' || !task.id.trim() || ids.has(task.id)) fail('INVALID_PLANNING_TASK', 'each planning task needs a unique id');
     ids.add(task.id);

package/src/orchestrator/rail-runtime.js

@@ -85,8 +85,7 @@ function loadProjectRail({ projectDir, handoff_id, clock }) {
 
 function internalTrackingInstallation(projectDir, clock) {
   const artifact = loadRuntimeInstallationV2(projectDir, { ...(clock === undefined ? {} : { clock }) });
-  return artifact?.installation?.profile === 'focus-ai-internal'
-    && artifact.installation.external_integrations?.clickup === 'required';
+  return artifact?.installation?.external_integrations?.clickup === 'required';
 }
 
 function assertCompletionMetricsEvidence(metrics, reviews, acceptanceEvidenceRefs, records, attemptId) {

package/src/orchestrator/runtime-installation-v2.js

@@ -48,9 +48,18 @@ export function resolveRuntimeInvocationV2({ artifact, agent, binding, model_id,
   if (!selectedCandidate) throw Object.assign(new Error(`No eligible installed model for ${agent}/${action}`), { code: 'NO_ELIGIBLE_MODEL' });
   const selected = selectedCandidate.binding;
   const model = selectedCandidate.model.model_id;
+  const defaultReasoning = selectedCandidate.model.tier === 'worker'
+    ? 'low'
+    : selectedCandidate.model.tier === 'workhorse'
+      ? 'medium'
+      : 'high';
   const invocation = {
     provider_id: selected.provider_id, harness_id: selected.harness_id, action,
-    model_pin: { model_id: model, catalog_snapshot_ref: artifact.capability_snapshot.snapshot_id, reasoning_configuration },
+    model_pin: {
+      model_id: model,
+      catalog_snapshot_ref: artifact.capability_snapshot.snapshot_id,
+      reasoning_configuration: reasoning_configuration ?? defaultReasoning,
+    },
   };
   assertEligibleInvocation({ installation: artifact.installation, snapshot: artifact.capability_snapshot, invocation, clock });
   return Object.freeze(invocation);

package/src/wizard/index.js

@@ -3,12 +3,13 @@ import { existsSync, readFileSync } from 'fs';
 import { join, dirname, basename } from 'path';
 import { fileURLToPath } from 'url';
 import { logBanner } from '../utils/logger.js';
-import { WIZARD_BACK, stepLanguage, stepProjectType, stepProviderSelection, stepEditorSelection, stepModelSelection, stepInstallationMode, stepConfirmation, stepTermsOfUse } from './questions.js';
+import { WIZARD_BACK, stepLanguage, stepProjectType, stepProviderSelection, 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 { checkClickUpMcp } from '../installer-v2/clickup-preflight.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';
@@ -72,18 +73,20 @@ export async function runWizard(targetDir, options = {}) {
   let catalogResolution;
   let modelSelections;
   let installationMode;
-  let selectedEditors;
+  let clickupPreflight = null;
+  // Editor rule files are a legacy programmatic integration. The interactive
+  // installer configures provider CLIs only, which are the actual runtimes.
+  const selectedEditors = options.editors || [];
   let config;
   let v2InstallationInput;
   let stage = 'project';
 
-  const stageOrder = ['language', 'project', 'providers', 'mode', 'editors', 'confirm'];
+  const stageOrder = ['language', 'project', 'providers', 'mode', 'confirm'];
   const optionKey = {
     language: 'language',
     project: 'projectType',
     providers: 'providers',
     mode: 'installationMode',
-    editors: 'editors',
   };
   const previousInteractiveStage = (current) => {
     for (let index = stageOrder.indexOf(current) - 1; index >= 0; index -= 1) {
@@ -127,9 +130,9 @@ export async function runWizard(targetDir, options = {}) {
       catalogResolution ??= options.signedCapabilityCatalogEnvelope
         ? { source: 'provided-signed', catalog: verifySignedCapabilityCatalog(options.signedCapabilityCatalogEnvelope, { publicKeyPem: options.catalogPublicKeyPem }) }
         : await resolveCapabilityCatalog({ projectDir: targetDir, catalogUrl: options.catalogUrl, fetchImpl: options.catalogFetch });
-      modelSelections = options.modelSelections !== undefined
-        ? options.modelSelections
-        : await stepModelSelection(selectedProviders, catalogResolution.catalog);
+      // Provider selection defines the permitted routing pool. Model discovery
+      // and task-specific choice stay inside the control plane.
+      modelSelections = options.modelSelections;
       stage = 'mode';
       continue;
     }
@@ -151,20 +154,12 @@ export async function runWizard(targetDir, options = {}) {
           p.log.error(error.message);
           continue;
         }
+        clickupPreflight = options.clickupPreflight || checkClickUpMcp(selectedProviders);
+        if (!clickupPreflight.passed) {
+          p.log.error('Internal mode requires an authorized ClickUp MCP connection in at least one selected CLI. Configure ClickUp in Claude, Codex or Grok, then retry.');
+          continue;
+        }
       }
-      stage = 'editors';
-      continue;
-    }
-
-    if (stage === 'editors') {
-      const value = options.editors !== undefined
-        ? options.editors
-        : await stepEditorSelection({ allowBack: previousInteractiveStage('editors') !== null });
-      if (value === WIZARD_BACK) {
-        stage = previousInteractiveStage('editors');
-        continue;
-      }
-      selectedEditors = value;
       stage = 'confirm';
       continue;
     }
@@ -185,6 +180,7 @@ export async function runWizard(targetDir, options = {}) {
       selectedIDEs,
       selectedMCPs,
       installationMode,
+      clickupPreflight,
       modelSelections,
       targetDir,
       version: VERSION,

package/src/wizard/questions.js

@@ -120,8 +120,8 @@ export async function stepProviderSelection({ allowBack = false } = {}) {
 }
 
 /**
- * Selects the operational policy profile. Focus AI internal projects require
- * ClickUp tracking; standard projects do not gain that external dependency.
+ * Selects the operational policy profile. Authorized internal projects require
+ * ClickUp tracking; open projects do not gain that external dependency.
  */
 export async function stepInstallationMode({ allowBack = false } = {}) {
   const mode = await p.select({
@@ -244,16 +244,12 @@ export async function stepIDESelection() {
  */
 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(', ')}`);
   }
 
-  p.note(summary.join('\n'), t('installer.model_routing_label'));
-
   return selections;
 }
 
@@ -261,7 +257,7 @@ export async function stepModelSelection(providers, capabilityCatalog) {
  * Step 4: Confirmation
  */
 export async function stepConfirmation(config, { allowBack = false } = {}) {
-  const { projectName, projectType, language, selectedMCPs, selectedIDEs, allProviders, installationMode } = config;
+  const { projectName, projectType, language, selectedMCPs, selectedIDEs, allProviders, installationMode, clickupPreflight } = config;
 
   const langName = SUPPORTED_LANGUAGES.find(l => l.value === language)?.label || language;
 
@@ -282,7 +278,6 @@ export async function stepConfirmation(config, { allowBack = false } = {}) {
     [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'),
@@ -293,6 +288,10 @@ export async function stepConfirmation(config, { allowBack = false } = {}) {
     summaryData[t('installer.ides_label')] = editorNames;
   }
 
+  if (installationMode === 'internal') {
+    summaryData.ClickUp = `Connected via ${(clickupPreflight?.connected_providers || []).join(', ')}`;
+  }
+
   summaryData[t('installer.mcps_label')] = mcpNames;
 
   console.log();