chati-dev 4.5.6 → 4.5.7

package/framework/config.yaml

@@ -1,8 +1,8 @@
 # chati.dev Configuration
-version: "4.5.6"
+version: "4.5.7"
 installed_at: "2026-02-07T10:00:00Z"
 updated_at: "2026-08-27T00:00:00Z"
-installer_version: "4.5.6"
+installer_version: "4.5.7"
 project_type: greenfield
 language: en
 ides: []

package/framework/context/root.md

@@ -1,7 +1,7 @@
 # Chati.dev System Context
 
 ## Framework
-- **Version**: 4.5.6
+- **Version**: 4.5.7
 - **Agents**: Specialized discovery and planning agents feeding provider-neutral RAIL execution and a sealed release lane
 - **Constitution**: 25 Articles + Preamble
 - **Quality**: 5 pipeline gates + 3-tier verdicts + Fault Vector Protocol (Article XXII)

package/framework/data/entity-registry.yaml

@@ -3,7 +3,7 @@
 # and by the Health Check for system integrity validation.
 
 metadata:
-  version: "4.5.6"
+  version: "4.5.7"
   last_updated: "2026-08-27T00:00:00Z"
   entity_count: 109
   checksum_algorithm: sha256

package/framework/manifest.json

@@ -1,5 +1,5 @@
 {
-  "createdAt": "2026-08-27T09:30:26.218Z",
+  "createdAt": "2026-08-27T10:57:24.520Z",
   "files": {
     "agents/build/dev.md": {
       "hash": "5c8da2eee3357bbe84a6c468c76fe60a0c77357575503c3797aa94128282c565",
@@ -97,7 +97,7 @@
       "type": "md"
     },
     "config.yaml": {
-      "hash": "77e84e99a6e31a664e9da640df949ef4d816359979ac0be093eb7e2c726298bc",
+      "hash": "394515115a919ac4b838cd58b3cf8f7cb34b535909b9a35f2d472cb51cc107ad",
       "size": 2669,
       "type": "yaml"
     },
@@ -122,12 +122,12 @@
       "type": "md"
     },
     "context/root.md": {
-      "hash": "57e0b456f520705cef15b47a4aa7bb9d159d26222a8e04c094064a0bce323c16",
+      "hash": "1058040823bbd394775a017f6b714b5f53ff6030f08113c191d1a477f8635e95",
       "size": 1217,
       "type": "md"
     },
     "data/entity-registry.yaml": {
-      "hash": "8852405c96cccf20672111d9367d0ebf87225e79eb966e56353d957ac6d7f037",
+      "hash": "8049c68d09ed547d64d1120f10a3f064f1c4f8313eacf8c2d267808e83a07265",
       "size": 34605,
       "type": "yaml"
     },
@@ -852,8 +852,8 @@
       "type": "json"
     },
     "schemas/session.schema.json": {
-      "hash": "f2ab86653c6e52a008268256198b9319de1602515aafd504bbbbe69df696c1de",
-      "size": 18014,
+      "hash": "57b0aa1b097b2253664a548cad42652ed3ec759feab6d0c1098062e88048cf1e",
+      "size": 19069,
       "type": "json"
     },
     "schemas/task.schema.json": {
@@ -1347,5 +1347,5 @@
       "type": "yaml"
     }
   },
-  "version": "4.5.6"
+  "version": "4.5.7"
 }

package/framework/manifest.sig

@@ -1 +1 @@
-vWBsUGE3V8dJWM3K5vpCFcUAeqdRor+u3DyDsIzUKtXE8le4HVw8hRvfMa9P4PDyoZvrY/smYteiHKZcdXeGDA==
+s4/05J4PlrCMfsXB3OMeVX+lE+7A2MMEycfr10Z+2uwgFh5DlWnSGxkMmCS4dZ3hVAWgSWDk7waAR8kA1JWNAw==

package/framework/schemas/session.schema.json

@@ -196,16 +196,33 @@
     },
     "model_selections": {
       "type": "array",
-      "description": "Model selection log for cost tracking (Article XVI)",
+      "description": "Append-only audit log of the exact execution binding used for each task (Article XVI)",
       "items": {
         "type": "object",
-        "required": ["agent", "recommended", "timestamp"],
+        "anyOf": [
+          {
+            "required": ["agent", "task_id", "provider", "model", "timestamp"],
+            "properties": {
+              "provider": { "enum": ["claude", "codex", "grok", "gemini"] }
+            }
+          },
+          {
+            "required": ["agent", "recommended", "timestamp"],
+            "not": { "required": ["task_id", "provider", "model"] }
+          }
+        ],
         "properties": {
           "agent": { "type": "string", "description": "Agent name" },
-          "recommended": { "enum": ["opus", "sonnet", "haiku"], "description": "Recommended model" },
-          "actual": { "enum": ["opus", "sonnet", "haiku"], "description": "Model actually used" },
-          "reason": { "type": "string", "description": "Why this model was selected (default, upgrade condition, no downgrade)" },
-          "provider": { "type": "string", "description": "CLI provider used (claude, gemini, codex)" },
+          "task_id": { "type": "string", "description": "Task identity supplied to the runner" },
+          "provider": { "type": "string", "description": "CLI harness that executed the task" },
+          "provider_id": { "type": ["string", "null"], "description": "Vendor provider identifier from the capability catalog" },
+          "model": { "type": "string", "minLength": 1, "description": "Exact model identifier used" },
+          "reasoning_configuration": { "enum": ["low", "medium", "high", "xhigh", "max", null], "description": "Reasoning effort passed to the CLI when supported" },
+          "catalog_snapshot_ref": { "type": ["string", "null"], "description": "Capability catalog snapshot used for routing" },
+          "status": { "enum": ["dispatched", "completed", "failed"], "default": "dispatched" },
+          "recommended": { "type": "string", "description": "Legacy pre-4.5.7 recommended model field, migrated on session load" },
+          "actual": { "type": "string", "description": "Legacy pre-4.5.7 actual model field, migrated on session load" },
+          "reason": { "type": "string", "description": "Legacy pre-4.5.7 selection reason" },
           "timestamp": { "type": "string", "format": "date-time" }
         }
       }
@@ -367,13 +384,13 @@
     "active_model": {
       "type": ["string", "null"],
       "default": null,
-      "description": "Normalized Claude model key (Article XII v2 / context-window-detection v1). Output of parseClaudeModelId — e.g. 'opus', 'opus[1m]', 'sonnet', 'haiku'. Written at /chati boot; drives context-limit resolution in hooks. Null = unknown (detection chain falls through to provider default)."
+      "description": "Model identifier detected for the current interactive harness. Written at /chati boot and used for context-window resolution. Per-task routed models are recorded separately in model_selections[]."
     },
     "active_provider": {
       "type": ["string", "null"],
-      "enum": ["claude", "gemini", "codex", null],
+      "enum": ["claude", "gemini", "codex", "grok", null],
       "default": null,
-      "description": "Active CLI provider. Redundant with providers_enabled[0] but flat for hook convenience."
+      "description": "Current interactive CLI harness. This is independent from the per-task provider recorded in model_selections[]."
     },
     "context_tokens_used": {
       "type": "integer",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "chati-dev",
-  "version": "4.5.6",
+  "version": "4.5.7",
   "description": "AI-Powered Multi-Agent Orchestration System - Structured vibe coding for Full Stack Development",
   "type": "module",
   "bin": {
@@ -77,6 +77,7 @@
     "chalk": "^5.3.0",
     "js-yaml": "^5.4.0",
     "ora": "^8.0.1",
+    "proper-lockfile": "4.1.2",
     "semver": "^7.6.0"
   },
   "bundleDependencies": [

package/src/installer/core.js

@@ -578,6 +578,10 @@ export function updateGitignore(targetDir, selectedIDEs) {
     '.chati/memories/*/session/',
     '# NOTE: durable/ and daily/ memories ARE committed — they contain project knowledge',
     '',
+    '# Operating system metadata',
+    '.DS_Store',
+    '._*',
+    '',
     '# Claude Code integration (framework portions only)',
     '.claude/commands/chati.md',
     '.claude/rules/chati/',

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',

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)