chati-dev 4.5.5 → 4.5.7

package/src/terminal/spawner.js

@@ -11,6 +11,7 @@ import { spawn } from 'child_process';
 import { validateWriteScopes, buildIsolationEnv } from './isolation.js';
 import { getProvider } from './cli-registry.js';
 import { getRateLimiter } from './rate-limiter.js';
+import { recordModelSelection } from '../orchestrator/session-manager.js';
 
 // ---------------------------------------------------------------------------
 // Constants
@@ -108,6 +109,9 @@ export function cleanParentEnv(env) {
  * @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, grok)
+ * @property {string} [providerId]    - Vendor provider identifier (anthropic, openai, xai)
+ * @property {string} [reasoningConfiguration] - Requested reasoning effort
+ * @property {string} [catalogSnapshotRef] - Capability catalog snapshot used for routing
  * @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
@@ -159,6 +163,7 @@ export function buildSpawnCommand(config) {
     CHATI_AGENT: config.agent,
     CHATI_TASK_ID: config.taskId,
     CHATI_SPAWNED: 'true',
+    ...(config.reasoningConfiguration ? { CHATI_REASONING_CONFIGURATION: config.reasoningConfiguration } : {}),
   };
 
   if (config.contextPayload) {
@@ -174,13 +179,20 @@ export function buildSpawnCommand(config) {
   const providerName = config.provider || 'claude';
   let command, args, prompt;
   let providerFallback = null;
+  let actualProvider = providerName;
+  let actualModel;
+  let actualReasoningConfiguration = null;
 
   try {
     const provider = getProvider(providerName);
-    const adapterResult = provider.adapter.buildCommand(config, provider);
+    const requestedModel = config.model || provider.defaultModel;
+    actualModel = provider.modelMap[requestedModel] || requestedModel;
+    const adapterResult = provider.adapter.buildCommand({ ...config, model: actualModel }, provider);
     command = adapterResult.command;
     args = adapterResult.args;
     prompt = adapterResult.stdinPrompt;
+    actualModel = adapterResult.effectiveModel;
+    actualReasoningConfiguration = adapterResult.effectiveReasoningConfiguration;
   } catch (err) {
     if (config.strictProvider) {
       const failure = new Error(`Selected provider "${providerName}" is unavailable: ${err.message}`);
@@ -194,18 +206,26 @@ export function buildSpawnCommand(config) {
       reason: err.message,
       timestamp: new Date().toISOString(),
     };
+    actualProvider = 'claude';
     console.error(`[chati] Provider "${providerName}" resolution failed: ${err.message}. Falling back to claude.`);
     command = 'claude';
     args = ['--print', '--dangerously-skip-permissions'];
-    if (config.model) {
-      const claudeProvider = getProvider('claude');
-      const resolvedModel = claudeProvider.modelMap[config.model] || config.model;
-      args.push('--model', resolvedModel);
+    const claudeProvider = getProvider('claude');
+    const requestedClaudeModel = config.model || 'sonnet';
+    actualModel = claudeProvider.modelMap[requestedClaudeModel]
+      || (requestedClaudeModel.startsWith('claude-') ? requestedClaudeModel : claudeProvider.modelMap.sonnet);
+    args.push('--model', actualModel);
+    if (config.reasoningConfiguration) {
+      args.push('--effort', config.reasoningConfiguration);
+      actualReasoningConfiguration = config.reasoningConfiguration;
     }
     prompt = config.prompt || null;
   }
 
-  return { command, args, env, terminalId, prompt, providerFallback };
+  return {
+    command, args, env, terminalId, prompt, providerFallback,
+    actualProvider, actualModel, actualReasoningConfiguration,
+  };
 }
 
 /**
@@ -215,11 +235,29 @@ export function buildSpawnCommand(config) {
  * @returns {TerminalHandle}
  */
 export function spawnTerminal(config) {
-  const { command, args, env, terminalId, prompt, providerFallback } = buildSpawnCommand(config);
+  const {
+    command, args, env, terminalId, prompt, providerFallback,
+    actualProvider, actualModel, actualReasoningConfiguration,
+  } = buildSpawnCommand(config);
 
   const cwd = config.workingDir || process.cwd();
   const timeout = config.timeout || 300_000; // default 5 minutes
 
+  const selectionRecord = recordModelSelection(cwd, {
+    agent: config.agent,
+    taskId: config.taskId,
+    provider: actualProvider,
+    providerId: providerFallback ? null : (config.providerId || null),
+    model: actualModel,
+    reasoningConfiguration: actualReasoningConfiguration,
+    catalogSnapshotRef: providerFallback ? null : (config.catalogSnapshotRef || null),
+  });
+  if (!selectionRecord.saved) {
+    const auditError = new Error(selectionRecord.error || 'Failed to persist model selection audit');
+    auditError.code = 'MODEL_SELECTION_AUDIT_FAILED';
+    throw auditError;
+  }
+
   const child = spawn(command, args, {
     cwd,
     env: { ...cleanParentEnv(process.env), ...env },
@@ -238,8 +276,9 @@ export function spawnTerminal(config) {
     process: child,
     agent: config.agent,
     taskId: config.taskId,
-    model: config.model || 'unknown',
-    provider: config.provider || 'claude',
+    model: actualModel || config.model || 'provider-default',
+    provider: actualProvider,
+    reasoningConfiguration: config.reasoningConfiguration || null,
     providerFallback,
     startedAt: new Date().toISOString(),
     status: 'running',
@@ -250,7 +289,7 @@ export function spawnTerminal(config) {
   };
 
   // Record spawn in rate limiter for throttling
-  const providerForRate = config.provider || 'claude';
+  const providerForRate = actualProvider;
   getRateLimiter(providerForRate).recordSpawn();
 
   // Capture output (capped at ~10MB to prevent unbounded memory growth)

package/src/wizard/index.js

@@ -9,6 +9,7 @@ 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,6 +73,7 @@ export async function runWizard(targetDir, options = {}) {
   let catalogResolution;
   let modelSelections;
   let installationMode;
+  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 || [];
@@ -152,6 +154,11 @@ 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 = 'confirm';
       continue;
@@ -173,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({
@@ -257,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;
 
@@ -288,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();