chati-dev 4.5.6 → 4.5.8

package/src/installer-v2/index.js

@@ -35,6 +35,54 @@ function assertString(value, code, label) {
   if (typeof value !== 'string' || value.trim() === '') throw new ContractError(code, `${label} must be a non-empty string`);
 }
 
+function assertExactKeys(value, allowedKeys, label) {
+  assertObject(value, 'INVALID_ARTIFACT', label);
+  const unexpected = Object.keys(value).filter((key) => !allowedKeys.has(key));
+  if (unexpected.length > 0) {
+    throw new ContractError('UNEXPECTED_ARTIFACT_FIELD', `${label} contains unsupported fields: ${unexpected.join(', ')}`);
+  }
+}
+
+const ARTIFACT_KEYS = new Set([
+  'schema_version', 'artifact_type', 'project_id', 'created_at', 'installation',
+  'capability_snapshot', 'brain_read_capability', 'managed_paths',
+  'installation_artifact_id', 'digest',
+]);
+const INSTALLATION_KEYS = new Set([
+  'installation_id', 'profile', 'enabled_providers', 'capability_snapshot_ref',
+  'policy_ref', 'primary_binding', 'primary_harness', 'external_integrations',
+]);
+const BINDING_KEYS = new Set([
+  'provider_id', 'harness_id', 'allowed_models', 'allowed_reasoning_configurations',
+]);
+const SNAPSHOT_KEYS = new Set(['snapshot_id', 'expires_at', 'models']);
+const MODEL_KEYS = new Set([
+  'provider_id', 'model_id', 'actions', 'adjudication_priority',
+  'highest_reasoning_configuration', 'routing_priority', 'tier', 'natural_role',
+]);
+
+function assertClosedArtifactSchema(artifact) {
+  assertExactKeys(artifact, ARTIFACT_KEYS, 'artifact');
+  assertExactKeys(artifact.installation, INSTALLATION_KEYS, 'installation');
+  for (const binding of artifact.installation.enabled_providers ?? []) {
+    assertExactKeys(binding, BINDING_KEYS, 'enabled provider binding');
+  }
+  if (artifact.installation.primary_binding !== undefined) {
+    assertExactKeys(artifact.installation.primary_binding, new Set(['provider_id', 'harness_id']), 'primary_binding');
+  }
+  if (artifact.installation.external_integrations !== undefined) {
+    assertExactKeys(artifact.installation.external_integrations, new Set(['clickup']), 'external_integrations');
+  }
+  assertExactKeys(artifact.capability_snapshot, SNAPSHOT_KEYS, 'capability_snapshot');
+  for (const model of artifact.capability_snapshot.models ?? []) {
+    assertExactKeys(model, MODEL_KEYS, 'capability model');
+  }
+  const brainKeys = artifact.brain_read_capability?.status === 'configured'
+    ? new Set(['status', 'mode', 'policy_ref'])
+    : new Set(['status']);
+  assertExactKeys(artifact.brain_read_capability, brainKeys, 'brain_read_capability');
+}
+
 function readClock(clock) {
   if (typeof clock !== 'function') throw new ContractError('MISSING_CLOCK', 'a deterministic clock function is required');
   const result = clock();
@@ -127,6 +175,7 @@ export function doctorV2(artifact, { clock = () => new Date() } = {}) {
   const checks = [];
   try {
     assertObject(artifact, 'INVALID_ARTIFACT', 'artifact');
+    assertClosedArtifactSchema(artifact);
     if (artifact.schema_version !== INSTALLATION_SCHEMA_VERSION || artifact.artifact_type !== 'chati-installation') {
       throw new ContractError('UNSUPPORTED_INSTALLATION_ARTIFACT', 'expected a chati installation artifact v2');
     }
@@ -138,6 +187,12 @@ export function doctorV2(artifact, { clock = () => new Date() } = {}) {
     if (!Array.isArray(artifact.managed_paths) || !artifact.managed_paths.every((path) => ensureRelativePath(path))) {
       throw new ContractError('INVALID_MANAGED_PATH', 'managed_paths must be valid project-relative paths');
     }
+    if (!artifact.managed_paths.includes(INSTALLATION_ARTIFACT_PATH)) {
+      throw new ContractError('INVALID_MANAGED_PATH', `managed_paths must include ${INSTALLATION_ARTIFACT_PATH}`);
+    }
+    if (new Set(artifact.managed_paths).size !== artifact.managed_paths.length) {
+      throw new ContractError('DUPLICATE_MANAGED_PATH', 'managed_paths must be unique');
+    }
     checks.push({ name: 'artifact', status: 'pass', message: 'artifact schema and digest are valid' });
     checks.push({ name: 'selected-bindings', status: 'pass', message: 'only explicitly selected provider/harness bindings are present' });
     checks.push({ name: 'brain-capability', status: 'pass', message: 'Brain capability is absent or read-only' });

package/src/orchestrator/cli.js

@@ -548,7 +548,7 @@ function sessionToPipelineState(session, projectDir) {
  * Build the spawn command string for an autonomous agent.
  * Exported for testing (path resolution must hold in every install layout).
  */
-export function buildSpawnCommand(agent, projectDir, previousAgent, provider, timeout, model = null, strictProvider = false) {
+export function buildSpawnCommand(agent, projectDir, previousAgent, provider, timeout, model = null, strictProvider = false, routing = {}) {
   const parts = [
     'node', RUNNER('run-agent.js'),
     '--agent', agent,
@@ -557,6 +557,9 @@ export function buildSpawnCommand(agent, projectDir, previousAgent, provider, ti
     '--previous-agent', previousAgent || 'none',
     '--provider', provider || 'claude',
     ...(model ? ['--model', model] : []),
+    ...(routing.provider_id ? ['--provider-id', routing.provider_id] : []),
+    ...(routing.reasoning_configuration ? ['--reasoning-configuration', routing.reasoning_configuration] : []),
+    ...(routing.catalog_snapshot_ref ? ['--catalog-snapshot-ref', routing.catalog_snapshot_ref] : []),
     ...(strictProvider ? ['--strict-provider'] : []),
     '--timeout', String(timeout || 600000),
   ];
@@ -591,7 +594,7 @@ export function buildRoutedParallelSpawnCommands(agents, projectDir, previousAge
       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'),
+      command: buildSpawnCommand(agent, projectDir, previousAgent, modelInfo.provider, timeout, modelInfo.model, modelInfo.source === 'installation-v2', modelInfo),
     });
   });
 }
@@ -849,7 +852,7 @@ async function _handleNextInner(projectDir) {
         agent,
         agent_file: agentFile,
         phase: agentDef?.phase || session.mode,
-        spawn_command: 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', modelInfo),
         parallel_spawn_command: null,
         parallel_agents: [],
         handoff_status: { valid: true, missing: [], warnings: ['Resuming in-progress agent'] },
@@ -878,7 +881,7 @@ async function _handleNextInner(projectDir) {
       agent: firstAgent,
       agent_file: agentFile,
       phase: 'discover',
-      spawn_command: buildSpawnCommand(firstAgent, projectDir, 'none', modelInfo.provider, 600000, modelInfo.model, modelInfo.source === 'installation-v2'),
+      spawn_command: buildSpawnCommand(firstAgent, projectDir, 'none', modelInfo.provider, 600000, modelInfo.model, modelInfo.source === 'installation-v2', modelInfo),
       parallel_spawn_command: null,
       parallel_agents: [],
       handoff_status: { valid: true, missing: [], warnings: [] },
@@ -979,10 +982,10 @@ async function _handleNextInner(projectDir) {
     teamData = { team_id: teamId, team_type: 'build', members: teamConfig.members };
   } else if (isInteractive) {
     action = 'spawn_routed_interactive';
-    spawnCommand = buildSpawnCommand(nextAgent, projectDir, lastAgent, modelInfo.provider, 600000, modelInfo.model, modelInfo.source === 'installation-v2');
+    spawnCommand = buildSpawnCommand(nextAgent, projectDir, lastAgent, modelInfo.provider, 600000, modelInfo.model, modelInfo.source === 'installation-v2', modelInfo);
   } else {
     action = 'spawn_autonomous';
-    spawnCommand = buildSpawnCommand(nextAgent, projectDir, lastAgent, modelInfo.provider, 600000, modelInfo.model, modelInfo.source === 'installation-v2');
+    spawnCommand = buildSpawnCommand(nextAgent, projectDir, lastAgent, modelInfo.provider, 600000, modelInfo.model, modelInfo.source === 'installation-v2', modelInfo);
   }
 
   // Surface criteria (Article XVII): even in autonomous mode, a high-stakes

package/src/orchestrator/session-manager.js

@@ -7,7 +7,8 @@
 
 import * as yaml from 'js-yaml';
 import { existsSync, readFileSync, writeFileSync, renameSync, mkdirSync } from 'fs';
-import { join, dirname } from 'path';
+import { join, dirname, resolve } from 'path';
+import lockfile from 'proper-lockfile';
 
 const SESSION_FILE = '.chati/session.yaml';
 
@@ -24,6 +25,35 @@ function writeFileAtomic(path, content, encoding = 'utf-8') {
   renameSync(tmp, path);
 }
 
+function waitForSessionWriteLock(sessionPath, maxWaitMs = 2000) {
+  const startedAt = Date.now();
+  while (true) {
+    try {
+      return lockfile.lockSync(sessionPath, {
+        realpath: false,
+        stale: 30_000,
+        update: 10_000,
+      });
+    } catch (err) {
+      if (err.code !== 'ELOCKED') throw err;
+      if (Date.now() - startedAt >= maxWaitMs) {
+        throw new Error(`Timed out waiting for session write lock after ${maxWaitMs}ms`, { cause: err });
+      }
+      Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, 20);
+    }
+  }
+}
+
+function findSessionProjectDir(startDir) {
+  let current = resolve(startDir);
+  while (true) {
+    if (existsSync(join(current, SESSION_FILE))) return current;
+    const parent = dirname(current);
+    if (parent === current) return null;
+    current = parent;
+  }
+}
+
 /**
  * Default session template.
  */
@@ -182,8 +212,31 @@ export function migrateSession(session) {
     return { migrated: false, fromVersion: null, toVersion: CURRENT_SCHEMA_VERSION };
   }
 
+  let normalizedLegacySelections = false;
+  if (Array.isArray(session.model_selections)) {
+    session.model_selections = session.model_selections.map((entry) => {
+      if (!entry || typeof entry !== 'object') return entry;
+      if (entry.task_id && entry.provider && entry.model) return entry;
+      const model = entry.actual || entry.recommended;
+      if (!entry.agent || !model || !entry.timestamp) return entry;
+      const provider = entry.provider || 'claude';
+      if (!['claude', 'codex', 'grok', 'gemini'].includes(provider)) return entry;
+      normalizedLegacySelections = true;
+      return {
+        ...entry,
+        task_id: entry.task_id || `${entry.agent}-legacy`,
+        provider,
+        provider_id: entry.provider_id || null,
+        model,
+        reasoning_configuration: entry.reasoning_configuration || null,
+        catalog_snapshot_ref: entry.catalog_snapshot_ref || null,
+        status: entry.status || 'dispatched',
+      };
+    });
+  }
+
   if (session.schema_version === CURRENT_SCHEMA_VERSION) {
-    return { migrated: false, fromVersion: session.schema_version, toVersion: CURRENT_SCHEMA_VERSION };
+    return { migrated: normalizedLegacySelections, fromVersion: session.schema_version, toVersion: CURRENT_SCHEMA_VERSION };
   }
 
   // v0 (no schema_version) → v1.0 → v1.1 → v1.2
@@ -294,22 +347,22 @@ export function loadSession(projectDir) {
 
   try {
     const content = readFileSync(sessionPath, 'utf-8');
-    const session = yaml.load(content);
+    let session = yaml.load(content);
 
     // Run migration if needed
     const migration = migrateSession(session);
     if (migration.migrated) {
-      try {
-        const yamlContent = yaml.dump(session, { lineWidth: -1, noRefs: true });
-        writeFileAtomic(sessionPath, yamlContent);
-      } catch (writeErr) {
+      const persisted = mutateSession(projectDir, current => current);
+      if (persisted.saved) {
+        session = persisted.session;
+      } else {
         // Migration write-back failed (read-only filesystem, EACCES). The
         // session continues with the migrated in-memory copy, but disk stays
         // on the old schema and re-migrates on every load. Surface it so the
         // user can fix the cause (make .chati/ writable) instead of it failing
         // silently. The production path (writable FS) never reaches here.
         process.stderr.write(
-          `[chati] warning: session migrated in memory but could not be written back to ${sessionPath} (${writeErr.code || writeErr.message}); it will re-migrate on every load until the directory is writable\n`
+          `[chati] warning: session migrated in memory but could not be written back to ${sessionPath} (${persisted.error}); it will re-migrate on every load until the directory is writable\n`
         );
       }
     }
@@ -336,115 +389,108 @@ export function loadSession(projectDir) {
  * @returns {{ saved: boolean }}
  */
 export function updateSession(projectDir, updates) {
-  const sessionPath = join(projectDir, SESSION_FILE);
-
-  // Load existing session
-  const loadResult = loadSession(projectDir);
-
-  if (!loadResult.loaded) {
-    return {
-      saved: false,
-      error: loadResult.error,
-    };
-  }
-
-  try {
+  return mutateSession(projectDir, (session) => {
     // Merge updates
     const merged = {
-      ...loadResult.session,
+      ...session,
       ...updates,
     };
 
     // Deep merge agents if provided
     if (updates.agents) {
       merged.agents = {
-        ...loadResult.session.agents,
+        ...session.agents,
         ...updates.agents,
       };
 
       // Merge individual agent data
       for (const [agentName, agentData] of Object.entries(updates.agents)) {
         merged.agents[agentName] = {
-          ...loadResult.session.agents[agentName],
+          ...session.agents[agentName],
           ...agentData,
         };
       }
     }
+    return merged;
+  });
+}
 
-    // Write back
-    const yamlContent = yaml.dump(merged, {
-      lineWidth: -1,
-      noRefs: true,
-    });
-
+function mutateSession(projectDir, mutator) {
+  const sessionPath = join(projectDir, SESSION_FILE);
+  if (!existsSync(sessionPath)) return { saved: false, error: 'Session file not found' };
+  let releaseLock = null;
+  let outcome;
+  try {
+    releaseLock = waitForSessionWriteLock(sessionPath);
+    const session = yaml.load(readFileSync(sessionPath, 'utf-8'));
+    if (!session || typeof session !== 'object' || Array.isArray(session)) {
+      throw new Error('Invalid session document');
+    }
+    migrateSession(session);
+    const nextSession = mutator(session) || session;
+    const yamlContent = yaml.dump(nextSession, { lineWidth: -1, noRefs: true });
     writeFileAtomic(sessionPath, yamlContent);
-
-    return {
-      saved: true,
-      session: merged,
-    };
+    outcome = { saved: true, session: nextSession };
   } catch (err) {
-    return {
-      saved: false,
-      error: `Failed to update session: ${err.message}`,
-    };
+    outcome = { saved: false, error: `Failed to update session: ${err.message}` };
+  } finally {
+    if (releaseLock) {
+      try {
+        releaseLock();
+      } catch (err) {
+        outcome = { saved: false, error: `Session write lock was compromised: ${err.message}` };
+      }
+    }
   }
+  return outcome;
 }
 
 /**
- * Record a mode transition in session history.
- * @param {string} projectDir
- * @param {object} transition - { from, to, trigger, reason }
- * @returns {{ saved: boolean }}
+ * Append the exact provider/model binding used for an execution.
+ * A short cross-process lock prevents parallel agents from overwriting each
+ * other's append-only audit entries.
  */
-export function recordModeTransition(projectDir, transition) {
-  const loadResult = loadSession(projectDir);
-
-  if (!loadResult.loaded) {
-    return {
-      saved: false,
-      error: loadResult.error,
-    };
-  }
-
-  const session = loadResult.session;
-
-  // Add transition to history
-  session.mode_transitions = session.mode_transitions || [];
-  session.mode_transitions.push({
-    from: transition.from,
-    to: transition.to,
-    trigger: transition.trigger || 'manual',
-    reason: transition.reason || '',
-    timestamp: new Date().toISOString(),
+export function recordModelSelection(projectDir, selection) {
+  const sessionProjectDir = findSessionProjectDir(projectDir);
+  if (!sessionProjectDir) return { saved: false, error: 'Session file not found in working directory or its parents' };
+
+  return mutateSession(sessionProjectDir, (session) => {
+    session.model_selections = Array.isArray(session.model_selections) ? session.model_selections : [];
+    session.model_selections.push({
+      agent: selection.agent,
+      task_id: selection.taskId,
+      provider: selection.provider,
+      provider_id: selection.providerId || null,
+      model: selection.model,
+      reasoning_configuration: selection.reasoningConfiguration || null,
+      catalog_snapshot_ref: selection.catalogSnapshotRef || null,
+      status: selection.status || 'dispatched',
+      timestamp: selection.timestamp || new Date().toISOString(),
+    });
+    return session;
   });
-
-  // Update current mode (both flat and nested for compatibility)
-  session.mode = transition.to;
-  if (session.project) {
-    session.project.state = transition.to;
-  }
-
-  return writeSessionToDisk(projectDir, session);
 }
 
 /**
- * Persist the full session object to disk. Avoids routing through updateSession's
- * spread+deep-merge logic (which can corrupt list fields like `completed_agents`
- * when the full session is passed as the updates arg).
+ * Record a mode transition in session history.
  * @param {string} projectDir
- * @param {object} session
- * @returns {{ saved: boolean, session?: object, error?: string }}
+ * @param {object} transition - { from, to, trigger, reason }
+ * @returns {{ saved: boolean }}
  */
-function writeSessionToDisk(projectDir, session) {
-  const sessionPath = join(projectDir, SESSION_FILE);
-  try {
-    const yamlContent = yaml.dump(session, { lineWidth: -1, noRefs: true });
-    writeFileAtomic(sessionPath, yamlContent);
-    return { saved: true, session };
-  } catch (err) {
-    return { saved: false, error: `Failed to write session: ${err.message}` };
-  }
+export function recordModeTransition(projectDir, transition) {
+  return mutateSession(projectDir, (session) => {
+    session.mode_transitions = session.mode_transitions || [];
+    session.mode_transitions.push({
+      from: transition.from,
+      to: transition.to,
+      trigger: transition.trigger || 'manual',
+      reason: transition.reason || '',
+      timestamp: new Date().toISOString(),
+    });
+    session.mode = transition.to;
+    if (session.project) session.project.state = transition.to;
+    return session;
+  });
 }
 
 /**
@@ -457,17 +503,8 @@ function writeSessionToDisk(projectDir, session) {
  * @returns {{ saved: boolean }}
  */
 export function recordAgentCompletion(projectDir, completion) {
-  const loadResult = loadSession(projectDir);
-
-  if (!loadResult.loaded) {
-    return {
-      saved: false,
-      error: loadResult.error,
-    };
-  }
-
-  const session = loadResult.session;
   const { agent, status, score, outputs = [], handoffData = {} } = completion;
+  return mutateSession(projectDir, (session) => {
 
   // Update agent data
   if (!session.agents[agent]) {
@@ -547,7 +584,8 @@ export function recordAgentCompletion(projectDir, completion) {
     }
   }
 
-  return writeSessionToDisk(projectDir, session);
+    return session;
+  });
 }
 
 /**

package/src/terminal/adapters/claude-adapter.js

@@ -19,15 +19,22 @@
  */
 export function buildCommand(config, provider) {
   const args = [...provider.baseArgs];
+  let effectiveModel = null;
 
   if (config.model) {
-    const resolvedModel = provider.modelMap[config.model] || config.model;
-    args.push(provider.modelFlag, resolvedModel);
+    effectiveModel = provider.modelMap[config.model] || config.model;
+    args.push(provider.modelFlag, effectiveModel);
+  }
+
+  if (config.reasoningConfiguration) {
+    args.push('--effort', config.reasoningConfiguration);
   }
 
   return {
     command: provider.command,
     args,
     stdinPrompt: config.prompt || null,
+    effectiveModel,
+    effectiveReasoningConfiguration: config.reasoningConfiguration || null,
   };
 }

package/src/terminal/adapters/codex-adapter.js

@@ -14,10 +14,15 @@
  */
 export function buildCommand(config, provider) {
   const args = [...provider.baseArgs];
+  let effectiveModel = null;
 
   if (config.model) {
-    const resolvedModel = provider.modelMap[config.model] || config.model;
-    args.push(provider.modelFlag, resolvedModel);
+    effectiveModel = provider.modelMap[config.model] || config.model;
+    args.push(provider.modelFlag, effectiveModel);
+  }
+
+  if (config.reasoningConfiguration) {
+    args.push('-c', `model_reasoning_effort=${JSON.stringify(config.reasoningConfiguration)}`);
   }
 
   // Codex exec reads prompt from stdin when `-` is passed
@@ -27,5 +32,7 @@ export function buildCommand(config, provider) {
     command: provider.command,
     args,
     stdinPrompt: config.prompt || null,
+    effectiveModel,
+    effectiveReasoningConfiguration: config.reasoningConfiguration || null,
   };
 }

package/src/terminal/adapters/gemini-adapter.js

@@ -14,15 +14,18 @@
  */
 export function buildCommand(config, provider) {
   const args = [...provider.baseArgs];
+  let effectiveModel = null;
 
   if (config.model) {
-    const resolvedModel = provider.modelMap[config.model] || config.model;
-    args.push(provider.modelFlag, resolvedModel);
+    effectiveModel = provider.modelMap[config.model] || config.model;
+    args.push(provider.modelFlag, effectiveModel);
   }
 
   return {
     command: provider.command,
     args,
     stdinPrompt: config.prompt || null,
+    effectiveModel,
+    effectiveReasoningConfiguration: null,
   };
 }

package/src/terminal/adapters/grok-adapter.js

@@ -7,10 +7,20 @@
  */
 export function buildCommand(config, provider) {
   const args = [...provider.baseArgs];
+  let effectiveModel = null;
   if (config.model) {
-    const resolvedModel = provider.modelMap[config.model] || config.model;
-    args.push(provider.modelFlag, resolvedModel);
+    effectiveModel = provider.modelMap[config.model] || config.model;
+    args.push(provider.modelFlag, effectiveModel);
+  }
+  if (config.reasoningConfiguration) {
+    args.push('--reasoning-effort', config.reasoningConfiguration);
   }
   args.push('-p', config.prompt || '');
-  return { command: provider.command, args, stdinPrompt: null };
+  return {
+    command: provider.command,
+    args,
+    stdinPrompt: null,
+    effectiveModel,
+    effectiveReasoningConfiguration: config.reasoningConfiguration || null,
+  };
 }

package/src/terminal/cli-registry.js

@@ -19,6 +19,7 @@ import { parseProviderConfig, parseAgentOverride } from '../utils/config-parser.
  * @property {string} command - CLI command name
  * @property {string[]} baseArgs - Default CLI arguments for non-interactive mode
  * @property {string} modelFlag - CLI flag for model selection
+ * @property {string} defaultModel - Explicit legacy default model alias
  * @property {boolean} stdinSupport - Whether prompts can be piped via stdin
  * @property {boolean} hooksSupport - Whether the CLI supports hooks (event middleware)
  * @property {boolean} mcpSupport - Whether the CLI supports MCP servers
@@ -34,6 +35,7 @@ const PROVIDERS = {
     command: 'claude',
     baseArgs: ['--print', '--dangerously-skip-permissions'],
     modelFlag: '--model',
+    defaultModel: 'sonnet',
     stdinSupport: true,
     hooksSupport: true,
     mcpSupport: true,
@@ -50,6 +52,7 @@ const PROVIDERS = {
     command: 'gemini',
     baseArgs: [],
     modelFlag: '--model',
+    defaultModel: 'pro',
     stdinSupport: true,
     hooksSupport: true,
     mcpSupport: true,
@@ -65,6 +68,7 @@ const PROVIDERS = {
     command: 'codex',
     baseArgs: ['exec'],
     modelFlag: '-m',
+    defaultModel: 'codex',
     stdinSupport: true,
     hooksSupport: false,
     mcpSupport: true,
@@ -80,6 +84,7 @@ const PROVIDERS = {
     command: 'grok',
     baseArgs: [],
     modelFlag: '-m',
+    defaultModel: 'grok',
     stdinSupport: false,
     hooksSupport: true,
     mcpSupport: true,

package/src/terminal/run-agent.js

@@ -130,6 +130,9 @@ async function main() {
       workingDir: projectDir,
       timeout,
       strictProvider: args['strict-provider'] === 'true',
+      providerId: args['provider-id'] || null,
+      reasoningConfiguration: args['reasoning-configuration'] || null,
+      catalogSnapshotRef: args['catalog-snapshot-ref'] || null,
     });
   } catch (err) {
     outputError(`Failed to spawn terminal: ${err.message}`);
@@ -144,6 +147,7 @@ async function main() {
       errorType: 'agent_failure',
       agent: args.agent,
       provider: promptResult.provider || args.provider || 'claude',
+      reasoningConfiguration: args['reasoning-configuration'] || null,
       phase: sessionState?.phase || 'unknown',
     });
     await flushAndSend(projectDir);
@@ -212,6 +216,7 @@ async function main() {
       agent: args.agent,
       model: promptResult.model,
       provider: promptResult.provider || args.provider || 'claude',
+      reasoningConfiguration: args['reasoning-configuration'] || null,
       exitCode: handle.exitCode,
       handoff: parsed.handoff,
       elapsed,

package/src/terminal/run-parallel.js

@@ -55,6 +55,9 @@ function createSpawnConfig({ agent, taskId, promptResult, projectDir, timeout, s
     workingDir: projectDir,
     timeout,
     strictProvider,
+    providerId: promptResult.providerId || null,
+    reasoningConfiguration: promptResult.reasoningConfiguration || null,
+    catalogSnapshotRef: promptResult.catalogSnapshotRef || null,
   };
 }
 
@@ -120,6 +123,10 @@ async function main() {
         strictProvider: args['strict-provider'] === 'true',
       });
 
+      promptResult.providerId = args['provider-id'] || null;
+      promptResult.reasoningConfiguration = args['reasoning-configuration'] || null;
+      promptResult.catalogSnapshotRef = args['catalog-snapshot-ref'] || null;
+
       configs.push(createSpawnConfig({
         agent: agents[i], taskId: taskIds[i], promptResult, projectDir, timeout,
         strictProvider: args['strict-provider'] === 'true',