chati-dev 4.5.10 → 4.5.12

package/src/terminal/run-agent.js

@@ -15,8 +15,9 @@
 
 import { fileURLToPath } from 'url';
 import { buildAgentPrompt } from './prompt-builder.js';
-import { spawnTerminal } from './spawner.js';
+import { isTransientFailure, spawnTerminalWithRetry } from './spawner.js';
 import { parseAgentOutput } from './handoff-parser.js';
+import { checkProviderReadiness } from './provider-preflight.js';
 import { createCostTracker } from './cost-tracker.js';
 import { getRateLimiter } from './rate-limiter.js';
 import { initCollector, track as telemetryTrack, flush as telemetryFlush } from '../telemetry/collector.js';
@@ -104,6 +105,11 @@ async function main() {
 
   // Wait for rate limit slot before spawning
   const spawnProvider = promptResult.provider || args.provider || 'claude';
+  const readiness = checkProviderReadiness(spawnProvider, { workingDir: projectDir });
+  if (!readiness.ready) {
+    outputResult({ status: 'error', error: readiness.detail, code: readiness.code, provider: spawnProvider });
+    process.exit(1);
+  }
   const limiter = getRateLimiter(spawnProvider);
   if (!limiter.canSpawn()) {
     const rateLimitStart = Date.now();
@@ -121,7 +127,7 @@ async function main() {
   let handle;
 
   try {
-    handle = spawnTerminal({
+    const spawnConfig = {
       agent: args.agent,
       taskId: args['task-id'],
       model: promptResult.model,
@@ -133,31 +139,25 @@ async function main() {
       providerId: args['provider-id'] || null,
       reasoningConfiguration: args['reasoning-configuration'] || null,
       catalogSnapshotRef: args['catalog-snapshot-ref'] || null,
+    };
+    handle = await spawnTerminalWithRetry(spawnConfig, {
+      maxRetries: 1,
+      baseDelay: 500,
+      enableModelFallback: args['strict-provider'] !== 'true',
+      shouldRetry(exitCode, output) {
+        const combined = Array.isArray(output) ? output.join('') : String(output || '');
+        return isTransientFailure(exitCode, combined) || /not logged in|not authenticated/i.test(combined);
+      },
     });
   } catch (err) {
     outputError(`Failed to spawn terminal: ${err.message}`);
     process.exit(1);
   }
 
-  // Wait for the process to complete
-  try {
-    await waitForExit(handle, timeout);
-  } catch (err) {
-    telemetryTrack('error_occurred', {
-      errorType: 'agent_failure',
-      agent: args.agent,
-      provider: promptResult.provider || args.provider || 'claude',
-      reasoningConfiguration: args['reasoning-configuration'] || null,
-      phase: sessionState?.phase || 'unknown',
-    });
-    await flushAndSend(projectDir);
-    outputError(`Terminal execution failed: ${err.message}`);
-    process.exit(2);
-  }
-
   const elapsed = Date.now() - startTime;
   const stdout = handle.stdout.join('');
   const stderr = handle.stderr.join('');
+  const providerOutput = `${stdout}\n${stderr}`;
 
   // Track cost metrics
   const tracker = createCostTracker();
@@ -186,7 +186,7 @@ async function main() {
     model: costRecord.model,
     duration: elapsed,
     score: null, // Score is determined by the gate, not the agent
-    retryCount: 0,
+    retryCount: handle.retryCount || 0,
     pipelineType: sessionState?.isQuickFlow ? 'quick-flow' : 'standard',
   });
 
@@ -210,7 +210,19 @@ async function main() {
   // Parse the handoff from stdout
   const parsed = parseAgentOutput(stdout);
 
-  if (parsed.found) {
+  if (handle.exitCode !== 0 && /not logged in|not authenticated/i.test(providerOutput)) {
+    outputResult({
+      status: 'error',
+      code: 'PROVIDER_AUTH_STATE_MISMATCH',
+      error: `${spawnProvider} passed preflight but rejected the spawned execution`,
+      provider: spawnProvider,
+      exitCode: handle.exitCode,
+      retryCount: handle.retryCount || 0,
+    });
+    process.exit(1);
+  }
+
+  if (parsed.found && parsed.valid) {
     outputResult({
       status: parsed.handoff.status,
       agent: args.agent,
@@ -222,15 +234,33 @@ async function main() {
       elapsed,
       costEstimate,
     });
+  } else if (recoverInteractiveHandoff(args.agent, stdout, handle.exitCode)) {
+    // Interactive discovery models sometimes answer with the user-facing
+    // question but omit the machine block. Preserve the exact question while
+    // restoring the deterministic relay contract for the parent orchestrator.
+    outputResult({
+      status: 'needs_input',
+      agent: args.agent,
+      model: promptResult.model,
+      provider: promptResult.provider || args.provider || 'claude',
+      exitCode: handle.exitCode,
+      handoff: recoverInteractiveHandoff(args.agent, stdout, handle.exitCode),
+      contractRecovery: 'interactive_output_wrapped',
+      elapsed,
+      costEstimate,
+    });
   } else {
-    // No handoff block found — return raw output
+    // A non-interactive agent that omits the handoff violated the execution
+    // contract and cannot be treated as successful or partially complete.
     outputResult({
-      status: handle.exitCode === 0 ? 'partial' : 'error',
+      status: 'error',
+      code: parsed.found ? 'INVALID_HANDOFF' : 'MISSING_HANDOFF',
       agent: args.agent,
       model: promptResult.model,
       provider: promptResult.provider || args.provider || 'claude',
       exitCode: handle.exitCode,
-      handoff: null,
+      handoff: parsed.handoff,
+      handoffWarnings: parsed.warnings,
       rawOutput: stdout.slice(0, 5000), // Truncate to avoid huge JSON
       stderr: stderr.slice(0, 2000),
       elapsed,
@@ -306,6 +336,19 @@ function outputError(message) {
   process.stdout.write(JSON.stringify({ status: 'error', error: message }) + '\n');
 }
 
+export function recoverInteractiveHandoff(agent, stdout, exitCode) {
+  if (exitCode !== 0 || !['greenfield-wu', 'brownfield-wu', 'brief'].includes(agent) || !stdout?.trim()) return null;
+  return {
+    status: 'needs_input',
+    score: null,
+    summary: 'Interactive agent requested user input.',
+    outputs: [],
+    decisions: {},
+    blockers: [],
+    needs_input_question: stdout.trim(),
+  };
+}
+
 /**
  * Minimal YAML parser for session.yaml (handles flat and one-level nested keys).
  */

package/src/terminal/spawner.js

@@ -579,11 +579,13 @@ export async function spawnTerminalWithRetry(config, retryOptions = {}) {
 
     // Success — return immediately
     if (handle.exitCode === 0) {
+      handle.retryCount = attempt;
       return handle;
     }
 
     // Check if failure is transient and retries remain
-    if (attempt < maxRetries && shouldRetry(handle.exitCode, handle.stderr)) {
+    const combinedOutput = [...(handle.stdout || []), ...(handle.stderr || [])];
+    if (attempt < maxRetries && shouldRetry(handle.exitCode, combinedOutput, handle)) {
       const delay = baseDelay * Math.pow(2, attempt);
       await new Promise(resolve => setTimeout(resolve, delay));
       continue;
@@ -617,9 +619,11 @@ export async function spawnTerminalWithRetry(config, retryOptions = {}) {
         timestamp: new Date().toISOString(),
       };
 
+      fallbackHandle.retryCount = maxRetries;
       return fallbackHandle;
     }
   }
 
+  if (lastHandle) lastHandle.retryCount = lastHandle.retryCount ?? maxRetries;
   return lastHandle;
 }

package/src/utils/schema-validator.js

@@ -169,7 +169,7 @@ export const SESSION_SCHEMA = {
   properties: {
     project: { type: 'string', required: true, minLength: 1 },
     language: { type: 'string', required: true, default: 'en' },
-    pipeline_phase: { type: 'string', enum: ['discover', 'plan', 'build', 'deploy', 'completed'] },
+    pipeline_phase: { type: 'string', enum: ['discover', 'plan', 'rail', 'release', 'build', 'validate', 'deploy', 'completed'] },
     current_agent: { type: 'string' },
     governance_mode: { type: 'string', enum: ['planning', 'build', 'deploy'] },
     execution_mode: { type: 'string', enum: ['interactive', 'autonomous'] },
@@ -201,7 +201,10 @@ export const CONFIG_SCHEMA = {
 export const HANDOFF_SCHEMA = {
   required: ['status'],
   properties: {
-    status: { type: 'string', required: true, enum: ['APPROVED', 'NEEDS_REVISION', 'BLOCKED', 'unknown'] },
+    status: { type: 'string', required: true, enum: [
+      'complete', 'partial', 'needs_input', 'error', 'unknown',
+      'APPROVED', 'NEEDS_REVISION', 'BLOCKED',
+    ] },
     score: { type: 'number', min: 0, max: 100 },
     summary: { type: 'string', maxLength: 2000 },
     outputs: { type: 'array' },

package/src/wizard/index.js

@@ -185,6 +185,7 @@ export async function runWizard(targetDir, options = {}) {
       modelSelections,
       targetDir,
       version: VERSION,
+      runtimeVersion: 2,
     };
     v2InstallationInput = buildWizardV2InstallationInput({
       projectName,