chati-dev 4.5.10 → 4.5.12

package/src/orchestrator/cli.js

@@ -53,7 +53,10 @@ import {
   recordEvent, EventType, clearTimeline,
 } from '../intelligence/timeline.js';
 import { updateClaudeMd } from '../memory/magic-docs.js';
-import { loadRuntimeInstallationV2, resolveRuntimeInvocationV2 } from './runtime-installation-v2.js';
+import {
+  loadRuntimeInstallationV2, resolveRuntimeInvocationV2,
+  describeRuntimeInstallationV2, V2_PLANNING_AGENTS,
+} from './runtime-installation-v2.js';
 import { compilePlanningHandoff, PLANNING_V2_TASKS_PATH } from './planning-runtime.js';
 import { persistRailHandoff } from './rail-runtime.js';
 
@@ -76,6 +79,8 @@ const LOCK_START = '<!-- chati-lock:start -->';
 const LOCK_END = '<!-- chati-lock:end -->';
 const STATE_START = '<!-- chati-state:start -->';
 const STATE_END = '<!-- chati-state:end -->';
+const PAUSE_START = '<!-- chati-pause:start -->';
+const PAUSE_END = '<!-- chati-pause:end -->';
 
 const RESUME_MESSAGES = {
   en: 'Session saved. Type /chati anytime to resume.',
@@ -84,6 +89,16 @@ const RESUME_MESSAGES = {
   fr: 'Session sauvee. Tapez /chati pour reprendre.',
 };
 
+function getRuntimeAgentPipeline(projectDir, session = null) {
+  if (!loadRuntimeInstallationV2(projectDir)) return AGENT_PIPELINE;
+  const projectType = session?.project_type || session?.project?.type || 'greenfield';
+  const selectedWu = projectType === 'brownfield' ? 'brownfield-wu' : 'greenfield-wu';
+  return AGENT_PIPELINE.filter(({ name }) =>
+    V2_PLANNING_AGENTS.includes(name)
+    && (!name.endsWith('-wu') || name === selectedWu)
+  );
+}
+
 // ---------------------------------------------------------------------------
 // QA-Visual scope helpers (Fase 6 — scope isolation)
 //
@@ -516,8 +531,13 @@ function errorResult(message, code) {
  */
 function sessionToPipelineState(session, projectDir) {
   const agents = {};
+  const installationV2 = loadRuntimeInstallationV2(projectDir);
+  const allowedAgents = installationV2
+    ? new Set(getRuntimeAgentPipeline(projectDir, session).map(({ name }) => name))
+    : null;
   if (session.agents) {
     for (const [name, data] of Object.entries(session.agents)) {
+      if (allowedAgents && !allowedAgents.has(name)) continue;
       agents[name] = {
         status: data.status || 'pending',
         score: data.score ?? null,
@@ -536,7 +556,9 @@ function sessionToPipelineState(session, projectDir) {
     startedAt: session.started_at || new Date().toISOString(),
     completedAt: null,
     agents,
-    completedAgents: session.completed_agents || [],
+    completedAgents: allowedAgents
+      ? (session.completed_agents || []).filter((name) => allowedAgents.has(name))
+      : (session.completed_agents || []),
     currentAgent: session.current_agent || null,
     modeTransitions: session.mode_transitions || [],
     history: [],
@@ -680,9 +702,32 @@ function replaceBlock(content, startMarker, endMarker, newInner) {
   return content.trimEnd() + '\n\n' + block + '\n';
 }
 
+function sessionLockTargets(projectDir) {
+  const frameworkDir = resolveFrameworkDir(projectDir);
+  return [
+    { path: join(projectDir, 'CLAUDE.local.md'), invocation: '/chati', provider: 'claude' },
+    { path: join(projectDir, 'AGENTS.override.md'), invocation: '$chati', provider: 'codex' },
+    { path: join(projectDir, '.grok', 'session-lock.md'), invocation: '/chati', provider: 'grok' },
+    { path: join(projectDir, '.gemini', 'session-lock.md'), invocation: '/chati', provider: 'gemini' },
+  ].map(target => ({
+    ...target,
+    orchestratorPath: existsSync(join(projectDir, frameworkDir, '.adapted', target.provider, 'orchestrator', 'chati.md'))
+      ? `${frameworkDir}/.adapted/${target.provider}/orchestrator/chati.md`
+      : `${frameworkDir}/orchestrator/chati.md`,
+  })).filter(({ path }) => path.endsWith('CLAUDE.local.md') || existsSync(path));
+}
+
+function removeLegacyPauseSection(content) {
+  let clean = content.replace(
+    /\n*<!-- chati-pause:start -->[\s\S]*?<!-- chati-pause:end -->\n*/g,
+    '\n'
+  );
+  // Migrate the unmarked block emitted by releases before 4.5.12.
+  clean = clean.replace(/\n+## Session Paused\n+[\s\S]*?(?=\n## |\n---|$)/g, '\n');
+  return clean;
+}
+
 function writeSessionLock(projectDir, currentAgent, stateInfo = {}) {
-  const localMdPath = join(projectDir, 'CLAUDE.local.md');
-  let content = existsSync(localMdPath) ? readFileSync(localMdPath, 'utf-8') : '';
 
   // Phase display is authoritatively driven by session.mode on disk. Callers
   // previously passed stateInfo.phase derived from transient intermediate
@@ -695,50 +740,51 @@ function writeSessionLock(projectDir, currentAgent, stateInfo = {}) {
     if (loaded && session?.mode) authoritativePhase = session.mode;
   } catch { /* non-fatal — fall back to stateInfo */ }
 
-  const lockInner = `## Session Lock -- ACTIVE
-
-**Chati.dev session is ACTIVE.** Follow these rules for EVERY message:
-
-1. Read \`${resolveFrameworkDir(projectDir)}/orchestrator/chati.md\` and follow its routing logic
-2. Route ALL user messages through the current agent: \`${currentAgent}\`
-3. NEVER respond outside of the Chati.dev system
-4. The ONLY way to exit is via \`/chati exit\`, \`/chati stop\`, or \`/chati quit\``;
-
   const stateInner = `## Current State
 - **Agent**: ${currentAgent || 'None'}
 - **Phase**: ${authoritativePhase || stateInfo.phase || 'discover'}
 - **Pipeline**: ${stateInfo.position ?? 0}/${stateInfo.total ?? '?'} (${stateInfo.progress ?? 0}%)
 - **Mode**: ${stateInfo.mode || 'interactive'}`;
 
-  content = replaceBlock(content, LOCK_START, LOCK_END, lockInner);
-  content = replaceBlock(content, STATE_START, STATE_END, stateInner);
-  writeFileSync(localMdPath, content, 'utf-8');
+  for (const target of sessionLockTargets(projectDir)) {
+    let content = removeLegacyPauseSection(existsSync(target.path) ? readFileSync(target.path, 'utf-8') : '');
+    const lockInner = `## Session Lock: ACTIVE
+
+**Chati.dev session is ACTIVE.** Follow these rules for EVERY message:
+
+1. Read \`${target.orchestratorPath}\` and follow its routing logic
+2. Route ALL user messages through the current agent: \`${currentAgent}\`
+3. NEVER respond outside of the Chati.dev system
+4. The ONLY way to exit is via \`${target.invocation} exit\`, \`${target.invocation} stop\`, or \`${target.invocation} quit\``;
+    content = replaceBlock(content, LOCK_START, LOCK_END, lockInner);
+    content = replaceBlock(content, STATE_START, STATE_END, stateInner);
+    writeFileSync(target.path, content.trimEnd() + '\n', 'utf-8');
+  }
 }
 
 /**
  * Remove session lock block from CLAUDE.local.md.
  */
 function removeSessionLock(projectDir, resumeMsg) {
-  const localMdPath = join(projectDir, 'CLAUDE.local.md');
-  if (!existsSync(localMdPath)) return;
-
-  let content = readFileSync(localMdPath, 'utf-8');
-
-  const lockInner = `## Session Lock
-**Status: INACTIVE** — Type \`/chati\` to activate.`;
   const stateInner = `## Current State
 - **Agent**: None (ready to start)
 - **Pipeline**: Pre-start
 - **Mode**: interactive`;
 
-  content = replaceBlock(content, LOCK_START, LOCK_END, lockInner);
-  content = replaceBlock(content, STATE_START, STATE_END, stateInner);
-
-  if (resumeMsg) {
-    content = content.trimEnd() + `\n\n## Session Paused\n\n${resumeMsg}\n`;
+  for (const target of sessionLockTargets(projectDir)) {
+    let content = removeLegacyPauseSection(existsSync(target.path) ? readFileSync(target.path, 'utf-8') : '');
+    const lockInner = `## Session Lock
+**Status: INACTIVE**: Type \`${target.invocation}\` to activate.`;
+    content = replaceBlock(content, LOCK_START, LOCK_END, lockInner);
+    content = replaceBlock(content, STATE_START, STATE_END, stateInner);
+
+    if (resumeMsg) {
+      const providerMessage = resumeMsg.replaceAll('/chati', target.invocation);
+      const pauseBlock = `${PAUSE_START}\n## Session Paused\n\n${providerMessage}\n${PAUSE_END}`;
+      content = content.trimEnd() + `\n\n${pauseBlock}\n`;
+    }
+    writeFileSync(target.path, content.trimEnd() + '\n', 'utf-8');
   }
-
-  writeFileSync(localMdPath, content.trimEnd() + '\n', 'utf-8');
 }
 
 // ---------------------------------------------------------------------------
@@ -767,11 +813,12 @@ async function handleNext(projectDir) {
     const activating = ['activate_interactive', 'spawn_routed_interactive', 'spawn_autonomous', 'spawn_team', 'spawn_parallel'];
     if (activating.includes(result.action)) {
       try {
+        const runtimePipeline = getRuntimeAgentPipeline(projectDir, result.session);
         writeSessionLock(projectDir, result.agent, {
           phase: result.phase || 'discover',
           mode: result.session?.execution_mode || 'interactive',
           position: result.pipeline_progress?.completedAgents?.length ?? 0,
-          total: AGENT_PIPELINE.length,
+          total: runtimePipeline.length,
           progress: result.pipeline_progress?.progress ?? 0,
         });
       } catch { /* non-fatal */ }
@@ -798,6 +845,38 @@ async function _handleNextInner(projectDir) {
     return errorResult(`Session invalid: ${validation.reason}`, 'SESSION_INVALID');
   }
 
+  const installationV2 = loadRuntimeInstallationV2(projectDir);
+  const runtimePipeline = getRuntimeAgentPipeline(projectDir, session);
+  if (installationV2 && session.rail_handoff_id) {
+    const completedPlanning = runtimePipeline.length;
+    return {
+      action: 'rail_execute',
+      agent: 'rail',
+      phase: 'rail',
+      handoff_id: session.rail_handoff_id,
+      rail_state: session.rail_state || 'ready',
+      pipeline_progress: {
+        phase: 'rail', progress: 100, completedCount: completedPlanning,
+        totalAgents: completedPlanning, completedAgents: session.completed_agents || [],
+        currentAgent: 'rail', nextAgent: null,
+      },
+      session: {
+        language: session.language,
+        project_type: session.project_type || session.project?.type,
+        execution_mode: session.execution_mode,
+      },
+      status_summary: 'Planning is sealed. Resume execution through RAIL.',
+    };
+  }
+
+  const legacyExecutionAgents = new Set(['dev', 'qa-implementation', 'qa-visual', 'devops']);
+  if (installationV2 && legacyExecutionAgents.has(session.current_agent)) {
+    return errorResult(
+      'A v2 installation cannot resume a legacy Build/Deploy agent. Re-seal Tasks to create the RAIL handoff.',
+      'V2_RAIL_HANDOFF_REQUIRED',
+    );
+  }
+
   const pipelineState = sessionToPipelineState(session, projectDir);
 
   if (isPipelineComplete(pipelineState)) {
@@ -836,7 +915,7 @@ async function _handleNextInner(projectDir) {
           handoff_status: { valid: true, missing: [], warnings: ['Resuming dev as Build Team'] },
           gate_status: { canAdvance: true, reason: 'Build Team formation (Article XXI)' },
           model_info: resolveAgentModel(agent, projectDir),
-          context_bracket: estimateContextBracket(completedAgents.length, AGENT_PIPELINE.length),
+          context_bracket: estimateContextBracket(completedAgents.length, runtimePipeline.length),
           pipeline_progress: getPipelineProgress(pipelineState),
           session: { language: session.language, project_type: session.project_type || session.project?.type, execution_mode: session.execution_mode, user_level: session.user_level || 'auto' },
           status_summary: `Forming Build Team: dev + qa-implementation.`,
@@ -858,7 +937,7 @@ async function _handleNextInner(projectDir) {
         handoff_status: { valid: true, missing: [], warnings: ['Resuming in-progress agent'] },
         gate_status: { canAdvance: true, reason: 'Agent already in progress' },
         model_info: modelInfo,
-        context_bracket: estimateContextBracket(completedAgents.length, AGENT_PIPELINE.length),
+        context_bracket: estimateContextBracket(completedAgents.length, runtimePipeline.length),
         pipeline_progress: getPipelineProgress(pipelineState),
         session: { language: session.language, project_type: session.project_type || session.project?.type, execution_mode: session.execution_mode, user_level: session.user_level || 'auto' },
         status_summary: `Resuming ${agent} (in progress).`,
@@ -887,7 +966,7 @@ async function _handleNextInner(projectDir) {
       handoff_status: { valid: true, missing: [], warnings: [] },
       gate_status: { canAdvance: true, reason: 'First agent in pipeline' },
       model_info: modelInfo,
-      context_bracket: estimateContextBracket(0, AGENT_PIPELINE.length),
+      context_bracket: estimateContextBracket(0, runtimePipeline.length),
       pipeline_progress: getPipelineProgress(pipelineState),
       session: { language: session.language, project_type: projectType, execution_mode: session.execution_mode, user_level: session.user_level || 'auto' },
       status_summary: `Starting pipeline with ${firstAgent}.`,
@@ -927,6 +1006,13 @@ async function _handleNextInner(projectDir) {
   const agentDef = getAgentDefinition(nextAgent);
   const isInteractive = INTERACTIVE_AGENTS.includes(nextAgent);
 
+  if (installationV2 && legacyExecutionAgents.has(nextAgent)) {
+    return errorResult(
+      'Planning reached the v2 execution boundary without a sealed RAIL handoff. Complete or re-run Tasks instead of entering Build/Deploy.',
+      'V2_RAIL_HANDOFF_REQUIRED',
+    );
+  }
+
   // Validate handoff from previous agent
   let handoffStatus;
   try {
@@ -1011,7 +1097,7 @@ async function _handleNextInner(projectDir) {
   recordEvent(projectDir, EventType.AGENT_ACTIVATED, nextAgent, { action, phase: agentDef?.phase });
 
   const progress = getPipelineProgress(pipelineState);
-  const bracket = estimateContextBracket(completedAgents.length, AGENT_PIPELINE.length);
+  const bracket = estimateContextBracket(completedAgents.length, runtimePipeline.length);
 
   const result = {
     action,
@@ -1851,6 +1937,8 @@ async function handleAdvance(projectDir, args) {
   // the handoff identifier and must enter the project-local RAIL lifecycle.
   if (handoffData.rail_handoff) {
     const railState = {
+      mode: 'rail',
+      project: { ...session.project, state: 'rail' },
       current_agent: 'rail',
       last_handoff: agent,
       pipeline_position: (session.completed_agents || []).length + 1,
@@ -1860,12 +1948,28 @@ async function handleAdvance(projectDir, args) {
     };
     const saved = await updateSession(projectDir, railState);
     if (saved && saved.saved === false) return errorResult(`Session update failed: ${saved.error}`, 'SESSION_WRITE_FAILED');
+    const runtimePipeline = getRuntimeAgentPipeline(projectDir, session);
+    try {
+      writeSessionLock(projectDir, 'rail', {
+        phase: 'rail', mode: session.execution_mode || 'interactive',
+        position: runtimePipeline.length, total: runtimePipeline.length, progress: 100,
+      });
+      updateClaudeMd(projectDir, {
+        currentAgent: 'rail',
+        progress: { progress: 100, completedCount: runtimePipeline.length, totalAgents: runtimePipeline.length },
+      });
+    } catch { /* non-fatal: the canonical session state has already been persisted */ }
     return {
       advanced: true,
       agent_completed: agent,
       score,
       rail_ready: true,
       rail_handoff: handoffData.rail_handoff,
+      pipeline_progress: {
+        phase: 'rail', progress: 100, completedCount: runtimePipeline.length,
+        totalAgents: runtimePipeline.length, completedAgents: [...(session.completed_agents || []), agent],
+        currentAgent: 'rail', nextAgent: null,
+      },
       next: {
         action: 'rail_execute',
         handoff_id: handoffData.rail_handoff.handoff.handoff_id,
@@ -2277,8 +2381,10 @@ async function handleStatus(projectDir) {
   }
 
   // Build model map for all agents
+  const runtimePipeline = getRuntimeAgentPipeline(projectDir, session);
+  const runtimeAgentNames = new Set(runtimePipeline.map(({ name }) => name));
   const agentModels = {};
-  for (const agentDef of AGENT_PIPELINE) {
+  for (const agentDef of runtimePipeline) {
     agentModels[agentDef.name] = resolveAgentModel(agentDef.name, projectDir);
   }
 
@@ -2309,9 +2415,9 @@ async function handleStatus(projectDir) {
     handoff_history: handoffHistory,
     deviation_count: (session.deviations || []).length,
     backlog: session.backlog || [],
-    agents: session.agents || {},
+    agents: Object.fromEntries(Object.entries(session.agents || {}).filter(([name]) => runtimeAgentNames.has(name))),
     agent_models: agentModels,
-    context_bracket: estimateContextBracket((session.completed_agents || []).length, AGENT_PIPELINE.length),
+    context_bracket: estimateContextBracket((session.completed_agents || []).length, runtimePipeline.length),
     context: {
       model:             activeModel,
       provider:          activeProvider,
@@ -2434,15 +2540,25 @@ async function handleExit(projectDir, args) {
 }
 
 async function handleProviders(projectDir) {
+  const artifact = loadRuntimeInstallationV2(projectDir);
+  if (artifact) {
+    const { session } = loadSession(projectDir);
+    const planningAgentModels = {};
+    for (const { name } of getRuntimeAgentPipeline(projectDir, session)) {
+      planningAgentModels[name] = resolveAgentModel(name, projectDir);
+    }
+    return {
+      ...describeRuntimeInstallationV2(artifact),
+      planning_agent_models: planningAgentModels,
+    };
+  }
+
   const agentModels = {};
   for (const agentDef of AGENT_PIPELINE) {
     agentModels[agentDef.name] = resolveAgentModel(agentDef.name, projectDir);
   }
 
-  const artifact = loadRuntimeInstallationV2(projectDir);
-  const enabledProviders = artifact
-    ? artifact.installation.enabled_providers.map(({ provider_id, harness_id }) => ({ provider_id, harness_id }))
-    : [...new Set(Object.values(agentModels).map(({ provider }) => provider).filter(Boolean))].map((harness_id) => ({ harness_id }));
+  const enabledProviders = [...new Set(Object.values(agentModels).map(({ provider }) => provider).filter(Boolean))].map((harness_id) => ({ harness_id }));
 
   return {
     enabled_providers: enabledProviders,

package/src/orchestrator/pipeline-manager.js

@@ -911,6 +911,8 @@ export function getPipelineProgress(pipelineState) {
   return {
     phase,
     progress: Math.round(progress),
+    completedCount: completed,
+    totalAgents,
     completedAgents,
     currentAgent,
     nextAgent,

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

@@ -10,6 +10,44 @@ const AGENT_ACTIONS = Object.freeze({
   devops: 'build',
 });
 
+export const V2_PLANNING_AGENTS = Object.freeze([
+  'greenfield-wu', 'brownfield-wu', 'brief',
+  'detail', 'architect', 'ux', 'qa-planning', 'phases', 'tasks',
+]);
+
+const RAIL_ACTIONS = new Set(['build', 'review']);
+
+export function describeRuntimeInstallationV2(artifact) {
+  const railExecutionPool = artifact.installation.enabled_providers.map((binding) => {
+    const capabilities = binding.allowed_models.flatMap((modelId) => {
+      const model = artifact.capability_snapshot.models.find((candidate) =>
+        candidate.provider_id === binding.provider_id && candidate.model_id === modelId
+      );
+      if (!model) return [];
+      const actions = model.actions.filter((action) => RAIL_ACTIONS.has(action));
+      if (actions.length === 0) return [];
+      return [{ model_id: modelId, actions, tier: model.tier || null }];
+    });
+    return {
+      provider_id: binding.provider_id,
+      harness_id: binding.harness_id,
+      models: capabilities.map(({ model_id }) => model_id),
+      capabilities,
+    };
+  }).filter(({ models }) => models.length > 0);
+
+  return Object.freeze({
+    architecture: 'chati-v2-rail',
+    enabled_providers: artifact.installation.enabled_providers.map(({ provider_id, harness_id }) => ({ provider_id, harness_id })),
+    rail_execution_pool: railExecutionPool,
+    release_lane: {
+      authority: 'explicit-human-authorization',
+      execution_authority: 'rail',
+      legacy_devops_agent: false,
+    },
+  });
+}
+
 export function loadRuntimeInstallationV2(projectDir, { clock = () => new Date() } = {}) {
   const path = join(projectDir, INSTALLATION_ARTIFACT_PATH);
   if (!existsSync(path)) return null;

package/src/orchestrator/session-manager.js

@@ -973,7 +973,7 @@ export function validateSession(projectDir) {
   }
 
   // Validate mode
-  const validModes = ['discover', 'plan', 'build', 'validate', 'deploy', 'completed'];
+  const validModes = ['discover', 'plan', 'rail', 'release', 'build', 'validate', 'deploy', 'completed'];
   if (!validModes.includes(session.mode)) {
     return {
       exists: true,

package/src/terminal/handoff-parser.js

@@ -14,7 +14,15 @@ import { validateSchema, HANDOFF_SCHEMA } from '../utils/schema-validator.js';
  * Valid status values for handoff blocks.
  * @type {string[]}
  */
-const VALID_STATUSES = ['APPROVED', 'NEEDS_REVISION', 'BLOCKED', 'unknown'];
+const VALID_STATUSES = [
+  'complete', 'partial', 'needs_input', 'error', 'unknown',
+  'APPROVED', 'NEEDS_REVISION', 'BLOCKED',
+];
+const LEGACY_STATUS_ALIASES = {
+  APPROVED: 'complete',
+  NEEDS_REVISION: 'partial',
+  BLOCKED: 'needs_input',
+};
 
 /**
  * Parse the <chati-handoff> block from agent stdout.
@@ -36,6 +44,7 @@ export function parseAgentOutput(output) {
 
   const content = match[1].trim();
   const handoff = parseHandoffFields(content);
+  handoff.status = LEGACY_STATUS_ALIASES[handoff.status] || handoff.status;
 
   // Validate the parsed handoff
   const { valid, warnings } = validateHandoff(handoff);
@@ -114,10 +123,11 @@ function parseHandoffFields(content) {
   for (const line of lines) {
     const trimmed = line.trim();
     if (!trimmed) continue;
+    const indentation = line.length - line.trimStart().length;
 
     // Check if this is a list item (  - value)
     const listMatch = trimmed.match(/^-\s+(.+)/);
-    if (listMatch && currentKey && currentType === 'list') {
+    if (indentation > 0 && listMatch && currentKey && currentType === 'list') {
       if (Array.isArray(result[currentKey])) {
         result[currentKey].push(listMatch[1].trim());
       }
@@ -126,7 +136,7 @@ function parseHandoffFields(content) {
 
     // Check if this is a map item (  key: value) under a map key
     const mapMatch = trimmed.match(/^(\w[\w_-]*):\s+(.+)/);
-    if (mapMatch && currentKey && currentType === 'map') {
+    if (indentation > 0 && mapMatch && currentKey && currentType === 'map') {
       if (typeof result[currentKey] === 'object' && !Array.isArray(result[currentKey])) {
         result[currentKey][mapMatch[1]] = mapMatch[2].trim();
       }
@@ -145,7 +155,10 @@ function parseHandoffFields(content) {
         currentType = 'list';
         // If value is inline (not empty), treat as single item
         if (value && value !== '') {
-          result[key] = [value];
+          if (value === '[]') result[key] = [];
+          else if (value.startsWith('[') && value.endsWith(']')) {
+            result[key] = value.slice(1, -1).split(',').map(item => item.trim()).filter(Boolean);
+          } else result[key] = [value];
           currentKey = null;
           currentType = null;
         }
@@ -154,6 +167,12 @@ function parseHandoffFields(content) {
 
       // Known map keys
       if (['decisions'].includes(key)) {
+        if (value === '{}') {
+          result[key] = {};
+          currentKey = null;
+          currentType = null;
+          continue;
+        }
         currentKey = key;
         currentType = 'map';
         continue;

package/src/terminal/prompt-builder.js

@@ -212,7 +212,11 @@ export function buildAgentPrompt(config) {
   // 9. Anti-laziness reinforcement (proven remediation techniques)
   sections.push(buildAntiLazinessSection(config.agent));
 
-  // 10. Output format instructions (handoff template — includes provider/model for audit)
+  // 10. Spawn authority. This late prompt section wins over stale provider
+  // context that may have been loaded before the synchronized session lock.
+  sections.push(buildSpawnAuthoritySection(config));
+
+  // 11. Output format instructions (handoff template — includes provider/model for audit)
   sections.push(buildOutputInstructions({ provider: resolvedProvider, model }));
 
   const prompt = sections.join('\n\n---\n\n');
@@ -233,6 +237,16 @@ export function buildAgentPrompt(config) {
   };
 }
 
+function buildSpawnAuthoritySection(config) {
+  return `<!-- SPAWN AUTHORITY -->
+## Active Orchestrator Assignment
+
+This process was launched by the active Chati.dev orchestrator for agent \`${config.agent}\`.
+Execute the assigned work now. Do not ask the user to activate Chati.dev, switch CLI, authenticate a provider, or restart the session.
+If essential user information is missing, return status \`needs_input\` with exactly one concrete question in \`needs_input_question\`.
+Never claim that this spawned session is paused. The parent orchestrator owns user interaction and will relay your structured handoff.`;
+}
+
 // ---------------------------------------------------------------------------
 // Internal helpers
 // ---------------------------------------------------------------------------

package/src/terminal/provider-preflight.js

@@ -0,0 +1,78 @@
+/**
+ * Deterministic provider readiness checks used immediately before a routed
+ * execution. These checks never mutate provider configuration.
+ */
+import { spawnSync } from 'node:child_process';
+import { getProvider } from './cli-registry.js';
+import { cleanParentEnv } from './spawner.js';
+
+const CHECKS = {
+  claude: { args: ['auth', 'status'], validate: validateClaude },
+  codex: { args: ['login', 'status'], validate: validateCodex },
+  grok: { args: ['inspect'], validate: validateGrok },
+  gemini: { args: ['--version'], validate: validateExit },
+};
+
+export function checkProviderReadiness(providerName, options = {}) {
+  const runner = options.runner || spawnSync;
+  let provider;
+  try {
+    provider = getProvider(providerName);
+  } catch (error) {
+    return { ready: false, code: 'PROVIDER_UNKNOWN', provider: providerName, detail: error.message };
+  }
+
+  const check = CHECKS[providerName] || { args: ['--version'], validate: validateExit };
+  let result;
+  try {
+    result = runner(provider.command, check.args, {
+      cwd: options.workingDir || process.cwd(),
+      env: cleanParentEnv(process.env),
+      encoding: 'utf8',
+      timeout: options.timeout || 30_000,
+    });
+  } catch (error) {
+    return { ready: false, code: 'PROVIDER_PREFLIGHT_FAILED', provider: providerName, detail: error.message };
+  }
+
+  if (result?.error?.code === 'ENOENT') {
+    return { ready: false, code: 'PROVIDER_CLI_MISSING', provider: providerName, detail: `${provider.command} is not installed` };
+  }
+  return check.validate(result, providerName);
+}
+
+function outputOf(result) {
+  return `${result?.stdout || ''}\n${result?.stderr || ''}`.trim();
+}
+
+function validateExit(result, provider) {
+  return result?.status === 0
+    ? { ready: true, code: 'PROVIDER_READY', provider }
+    : { ready: false, code: 'PROVIDER_NOT_READY', provider, detail: outputOf(result).slice(0, 500) };
+}
+
+function validateClaude(result, provider) {
+  if (result?.status !== 0) return validateExit(result, provider);
+  try {
+    const status = JSON.parse(result.stdout || '{}');
+    return status.loggedIn === true
+      ? { ready: true, code: 'PROVIDER_READY', provider }
+      : { ready: false, code: 'PROVIDER_NOT_AUTHENTICATED', provider, detail: 'Claude CLI reports loggedIn=false' };
+  } catch {
+    return { ready: false, code: 'PROVIDER_PREFLIGHT_INVALID', provider, detail: 'Claude CLI returned an invalid auth status' };
+  }
+}
+
+function validateCodex(result, provider) {
+  if (result?.status !== 0) return validateExit(result, provider);
+  return /logged in/i.test(outputOf(result))
+    ? { ready: true, code: 'PROVIDER_READY', provider }
+    : { ready: false, code: 'PROVIDER_NOT_AUTHENTICATED', provider, detail: 'Codex CLI did not confirm an authenticated session' };
+}
+
+function validateGrok(result, provider) {
+  // Grok currently exposes no stable auth-status command. `inspect` proves
+  // that the CLI can load the trusted project and its effective config.
+  return validateExit(result, provider);
+}
+