chati-dev 4.5.5 → 4.5.7

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