@the-open-engine/zeroshot 6.31.3 → 6.32.1

package/src/agent/agent-task-executor.js

@@ -52,6 +52,10 @@ const {
   validateCompletedResumeIdentity,
 } = require('./provider-session');
 const { extractClaudeVertexModelError } = require('./output-extraction');
+const {
+  createStructuredOutputInvalidError,
+  isStructuredOutputInvalidError,
+} = require('./structured-output-error');
 const TASK_TERMINAL_STATUSES = new Set(['completed', 'failed', 'killed', 'stale']);
 function runCommandWithTimeout(command, args, options = {}, callback = null) {
   const timeout = options.timeout ?? 30000;
@@ -1412,6 +1416,7 @@ async function evaluateStructuredSuccess({ agent, taskId, state, success, allowR
     return { success: true, error: null };
   } catch (error) {
     if (
+      isStructuredOutputInvalidError(error) ||
       isNestedLifecycleError(error) ||
       error?.permanent === true ||
       error?.recoveryAbort === true
@@ -2858,7 +2863,10 @@ async function parseResultOutput(agent, output, { allowRecovery = true } = {}) {
   const schema = agent.config.jsonSchema;
   if (!schema) {
     if (parsed) return parsed;
-    throw new Error(`Agent ${agent.id} output missing required JSON block`);
+    throw createStructuredOutputInvalidError(
+      `Agent ${agent.id} output missing required JSON block`,
+      'missing_json'
+    );
   }
 
   const { createStructuredOutputValidator, reformatOutput } = require('./output-reformatter');
@@ -2911,7 +2919,12 @@ async function parseResultOutput(agent, output, { allowRecovery = true } = {}) {
       throw new Error('Task execution failed - no output');
     }
     const recoveryDetail = recovery?.lastError ? ` Recovery exhausted: ${recovery.lastError}.` : '';
-    throw new Error(`Agent ${agent.id} output missing required JSON block.${recoveryDetail}`);
+    throw createStructuredOutputInvalidError(
+      `Agent ${agent.id} output missing required JSON block.${recoveryDetail}`,
+      'missing_json',
+      directValidation,
+      recovery
+    );
   }
 
   if (!allowRecovery) {
@@ -2921,13 +2934,18 @@ async function parseResultOutput(agent, output, { allowRecovery = true } = {}) {
 
   const errorDetail = directValidation?.error || 'unknown schema error';
   const message = `Agent ${agent.id} output failed JSON schema validation: ${errorDetail}`;
-  if (agent.role === 'validator') {
-    throw new Error(
-      recovery?.status === 'exhausted'
-        ? `${message}. Recovery exhausted after ${recovery.attempts} attempts: ${recovery.lastError}`
-        : message
+  const terminalStructuredRole = ['planner', 'conductor', 'validator'].includes(agent.role);
+  if (recovery?.status === 'exhausted' && terminalStructuredRole) {
+    throw createStructuredOutputInvalidError(
+      `${message}. Recovery exhausted after ${recovery.attempts} attempts: ${recovery.lastError}`,
+      'schema_validation',
+      directValidation,
+      recovery
     );
   }
+  if (agent.role === 'validator') {
+    throw new Error(message);
+  }
 
   console.warn(`⚠️  ${message}`);
   agent._publish({

package/src/agent/structured-output-error.js

@@ -0,0 +1,42 @@
+const STRUCTURED_OUTPUT_INVALID_CODE = 'STRUCTURED_OUTPUT_INVALID';
+
+function createStructuredOutputInvalidError(message, kind, validation = null, recovery = null) {
+  const error = new Error(message);
+  error.code = STRUCTURED_OUTPUT_INVALID_CODE;
+  error.details = {
+    kind,
+    validationError: validation?.error ?? null,
+    recoveryAttempts: recovery?.status === 'exhausted' ? recovery.attempts : 0,
+    recoveryError: recovery?.status === 'exhausted' ? recovery.lastError : null,
+  };
+  return error;
+}
+
+function isStructuredOutputInvalidError(error) {
+  return error?.code === STRUCTURED_OUTPUT_INVALID_CODE;
+}
+
+function buildStructuredOutputClusterFailure(agent, error) {
+  return {
+    topic: 'CLUSTER_FAILED',
+    receiver: 'broadcast',
+    content: {
+      text: `Cluster failed: structured output is invalid for ${agent.id} - ${error.message}`,
+      data: {
+        reason: 'structured_output_invalid',
+        agentId: agent.id,
+        role: agent.role,
+        code: error.code,
+        details: error.details ?? null,
+        error: error.message,
+      },
+    },
+  };
+}
+
+module.exports = {
+  STRUCTURED_OUTPUT_INVALID_CODE,
+  createStructuredOutputInvalidError,
+  isStructuredOutputInvalidError,
+  buildStructuredOutputClusterFailure,
+};

package/src/agent-cli-provider/adapters/codex.ts

@@ -255,7 +255,9 @@ function assertStructuredOutputRecoveryFeatures(options: BuildProviderCommandOpt
   const missing = [
     ['--sandbox', features.supportsSandbox],
     ['--ephemeral', features.supportsEphemeral],
-    ['--ignore-user-config', features.supportsIgnoreUserConfig],
+    ...(options.trustIsolatedCodexProfile === true
+      ? []
+      : [['--ignore-user-config', features.supportsIgnoreUserConfig] as const]),
     ['--ignore-rules', features.supportsIgnoreRules],
     ['--strict-config', features.supportsStrictConfig],
     ['--config', features.supportsConfigOverride],
@@ -284,17 +286,11 @@ function buildStructuredOutputRecoveryCommand(
   const args = [...spec.args];
   const prompt = args.pop();
   if (prompt === undefined) throw new Error('Codex recovery command is missing its prompt');
-  args.push(
-    '--sandbox',
-    'read-only',
-    '--ephemeral',
-    '--ignore-user-config',
-    '--ignore-rules',
-    '--strict-config',
-    '--config',
-    'web_search="disabled"',
-    prompt
-  );
+  args.push('--sandbox', 'read-only', '--ephemeral');
+  if (options.trustIsolatedCodexProfile !== true) {
+    args.push('--ignore-user-config');
+  }
+  args.push('--ignore-rules', '--strict-config', '--config', 'web_search="disabled"', prompt);
   return { ...spec, args };
 }
 

package/src/agent-cli-provider/provider-registry.ts

@@ -276,9 +276,9 @@ export const providerRegistry = [
     authInstructions: 'codex login',
     credentialPaths: ['~/.config/codex', '~/.codex'],
     credentialEnvKeys: codexAdapter.credentialEnvKeys,
-    settingsFields: ['webSearch'],
-    settingsDefaults: { webSearch: false },
-    settingsValidator: (settings): string | null => validateWebSearchSettings('codex', settings),
+    settingsFields: ['webSearch', 'trustIsolatedRecoveryProfile'],
+    settingsDefaults: { webSearch: false, trustIsolatedRecoveryProfile: false },
+    settingsValidator: validateCodexSettings,
     capabilities: {
       ...STANDARD_CAPABILITIES,
       jsonSchema: true,
@@ -662,6 +662,18 @@ export const providerRegistry = [
   },
 ] as const satisfies readonly ProviderRegistryEntry[];
 
+function validateCodexSettings(settings: Record<string, unknown>): string | null {
+  const webSearchError = validateWebSearchSettings('codex', settings);
+  if (webSearchError) return webSearchError;
+  if (
+    settings.trustIsolatedRecoveryProfile === undefined ||
+    typeof settings.trustIsolatedRecoveryProfile === 'boolean'
+  ) {
+    return null;
+  }
+  return 'providerSettings.codex.trustIsolatedRecoveryProfile must be a boolean';
+}
+
 function validateWebSearchSettings(
   provider: 'codex' | 'opencode',
   settings: Record<string, unknown>

package/src/agent-cli-provider/single-agent-runtime.ts

@@ -54,16 +54,12 @@ import type {
 
 type UnknownFunction = (...args: readonly unknown[]) => unknown;
 
-interface CommandParts {
-  readonly command: string;
-  readonly args: readonly string[];
-}
-
 interface RuntimeProviderSettings {
   readonly defaultLevel?: ModelLevel;
   readonly levelOverrides: LevelOverrides;
   readonly gateway?: GatewayBuildOptions;
   readonly webSearch?: boolean;
+  readonly trustIsolatedRecoveryProfile?: boolean;
 }
 
 interface RuntimeCommandContext {
@@ -428,7 +424,6 @@ function ompExecutionContext(
   throw new Error('options.executionContext must be "host", "detached", "docker", or "benchmark".');
 }
 
-
 function ompSdkOutputContract(
   options: BuildProviderCommandOptions
 ):
@@ -664,7 +659,7 @@ export function probeRuntimeProviderCli(
   const requested = registryEntry.settingsFields.includes('webSearch')
     ? runtimeProviderSettings(settings, adapter.id, process.cwd()).webSearch === true
     : false;
-  const helpCommand = runtimeHelpCommand(adapter.id);
+  const helpCommand = resolveProviderCommand(adapter.id);
   const commandAvailable =
     evidence === undefined
       ? booleanResult(commandExistsFn(helpCommand.command))
@@ -735,6 +730,10 @@ function buildRuntimeOptions(
     cliFeatures: runtime.cliFeatures,
   };
   const resolved = { ...baseResolved };
+  delete resolved.trustIsolatedCodexProfile;
+  if (baseOptions.structuredOutputRecovery && adapter.id === 'codex') {
+    resolved.trustIsolatedCodexProfile = providerSettings.trustIsolatedRecoveryProfile === true;
+  }
   if (baseOptions.structuredOutputRecovery) {
     delete resolved.resumeSessionId;
     delete resolved.continueSession;
@@ -870,6 +869,10 @@ function runtimeProviderSettings(
     providerSettings.webSearch,
     `settings.providerSettings.${provider}.webSearch`
   );
+  const trustIsolatedRecoveryProfile = optionalBoolean(
+    providerSettings.trustIsolatedRecoveryProfile,
+    `settings.providerSettings.${provider}.trustIsolatedRecoveryProfile`
+  );
   const gateway =
     provider === 'gateway'
       ? normalizeGatewayBuildOptions(providerSettings, 'settings.providerSettings.gateway', cwd)
@@ -878,14 +881,11 @@ function runtimeProviderSettings(
     levelOverrides,
     ...(gateway === undefined ? {} : { gateway }),
     ...(webSearch === undefined ? {} : { webSearch }),
+    ...(trustIsolatedRecoveryProfile === undefined ? {} : { trustIsolatedRecoveryProfile }),
   };
   return defaultLevel === undefined ? base : { ...base, defaultLevel };
 }
 
-function runtimeHelpCommand(provider: ProviderId): CommandParts {
-  return resolveProviderCommand(provider);
-}
-
 function probeGatewayProvider(
   adapter: ProviderAdapter,
   runtimeSettings?: Record<string, unknown>

package/src/agent-cli-provider/types.ts

@@ -468,6 +468,8 @@ export interface BuildProviderCommandOptions {
   readonly mcpConfig?: readonly string[];
   /** Internal profile for provider-neutral structured-output correction turns. */
   readonly structuredOutputRecovery?: boolean;
+  /** Preserve a caller-isolated CODEX_HOME profile during Codex recovery. */
+  readonly trustIsolatedCodexProfile?: boolean;
 }
 
 export interface TextEvent {

package/src/preflight.js

@@ -468,6 +468,31 @@ function validateProviderIsolationCapabilities(providerName, options) {
   return errors;
 }
 
+function validateProviderExecutionSettings(providerName, settings, options) {
+  const metadata = getProviderMetadata(providerName);
+  if (!metadata.settingsValidator) return [];
+
+  const providerSettings = settings.providerSettings?.[providerName];
+  if (
+    !providerSettings ||
+    typeof providerSettings !== 'object' ||
+    Array.isArray(providerSettings)
+  ) {
+    return [];
+  }
+
+  const executionContext = options.requireDocker ? 'docker' : 'detached';
+  const error = metadata.settingsValidator(providerSettings, { executionContext });
+  if (!error) return [];
+
+  return [
+    formatError(`${metadata.displayName} configuration cannot run cluster agents`, error, [
+      metadata.authInstructions,
+      'Or select a different provider with: zeroshot providers set-default <provider>',
+    ]),
+  ];
+}
+
 function validateProvider(providerName, options) {
   let metadata;
   try {
@@ -623,7 +648,7 @@ async function runPreflight(options = {}) {
   const errors = [];
   const warnings = [];
 
-  const settings = loadSettings();
+  const settings = options.settings || loadSettings();
 
   if (process.platform === 'win32') {
     return {
@@ -648,6 +673,7 @@ async function runPreflight(options = {}) {
 
   const providerResult = validateProvider(providerName, options);
   errors.push(...providerResult.errors);
+  errors.push(...validateProviderExecutionSettings(providerName, settings, options));
   warnings.push(...providerResult.warnings);
 
   // 4. Check issue provider CLI (if required)

package/src/status-footer.js

@@ -151,21 +151,29 @@ class StatusFooter {
   }
 
   /**
-   * Print text to stdout, coordinating with the render cycle.
-   * When a render is in progress, queues output to prevent cursor corruption.
-   * When no render is active, writes immediately.
-   *
-   * MUST be used instead of console.log() when status footer is active.
-   * @param {string} text - Text to print (newline will be added)
+   * Print one logical line while coordinating with footer rendering.
+   * The caller owns line normalization; this method appends one newline.
+   * @param {string} text
    */
   print(text) {
+    this._queueOrWrite(`${text}\n`);
+  }
+
+  /**
+   * Write an exact streaming chunk while coordinating with footer rendering.
+   * @param {string} text
+   */
+  write(text) {
+    this._queueOrWrite(String(text));
+  }
+
+  /** @private */
+  _queueOrWrite(text) {
     if (this.isRendering) {
-      // Queue for later - render() will flush after restoring cursor
       this.printQueue.push(text);
-    } else {
-      // Write immediately - no render in progress
-      process.stdout.write(text + '\n');
+      return;
     }
+    process.stdout.write(text);
   }
 
   /**
@@ -176,8 +184,7 @@ class StatusFooter {
   _flushPrintQueue() {
     if (this.printQueue.length === 0) return;
 
-    // Write all queued output
-    const output = this.printQueue.map((text) => text + '\n').join('');
+    const output = this.printQueue.join('');
     this.printQueue = [];
     process.stdout.write(output);
   }

package/task-lib/commands/list.js

@@ -1,97 +1,109 @@
 import chalk from 'chalk';
+import { resolveEffectiveTaskStatus } from '../effective-status.js';
 import { loadTasks } from '../store.js';
-import { isProcessRunning } from '../runner.js';
 
-export function listTasks(options = {}) {
-  const tasks = loadTasks();
-  const taskList = Object.values(tasks);
+const DEFAULT_LIMIT = 20;
+
+function selectTasks(options = {}, deps = {}) {
+  const readTasks = deps.loadTasks || loadTasks;
+  const resolveStatus = deps.resolveEffectiveTaskStatus || resolveEffectiveTaskStatus;
+  const allTasks = Object.values(readTasks());
+  const selected = allTasks
+    .map((task) => ({ task, effectiveStatus: resolveStatus(task) }))
+    .sort((left, right) => new Date(left.task.createdAt) - new Date(right.task.createdAt))
+    .filter(({ effectiveStatus }) => !options.status || effectiveStatus.status === options.status)
+    .slice(0, options.limit || DEFAULT_LIMIT);
+  return { total: allTasks.length, selected };
+}
+
+function projectTask({ task, effectiveStatus }) {
+  return {
+    id: task.id,
+    status: effectiveStatus.status,
+    statusReason: effectiveStatus.reason,
+    cwd: task.cwd,
+    provider: task.provider || null,
+    model: task.model || null,
+    createdAt: task.createdAt,
+    updatedAt: task.updatedAt,
+    exitCode: task.exitCode ?? null,
+    error: task.error || null,
+    attachable: task.attachable === true,
+  };
+}
+
+export function getTasksData(options = {}, deps = {}) {
+  return selectTasks(options, deps).selected.map(projectTask);
+}
 
-  if (taskList.length === 0) {
+export function listTasks(options = {}, deps = {}) {
+  const { selected, total } = selectTasks(options, deps);
+
+  if (total === 0) {
     console.log(chalk.dim('No tasks found.'));
     return;
   }
 
-  // Sort by creation date, oldest first (chronological)
-  taskList.sort((a, b) => new Date(a.createdAt) - new Date(b.createdAt));
-
-  // Filter by status if specified
-  let filtered = taskList;
-  if (options.status) {
-    filtered = taskList.filter((t) => t.status === options.status);
+  if (options.verbose) {
+    printVerboseTasks(selected, total);
+  } else {
+    printTaskTable(selected, total);
   }
+}
 
-  // Limit results
-  const limit = options.limit || 20;
-  filtered = filtered.slice(0, limit);
-
-  // Table format (default) or verbose format
-  if (options.verbose) {
-    // Verbose format (old behavior)
-    console.log(chalk.bold(`\nTasks (${filtered.length}/${taskList.length})\n`));
-
-    for (const task of filtered) {
-      // Verify running status
-      let status = task.status;
-      if (status === 'running' && !isProcessRunning(task.pid)) {
-        status = 'stale';
-      }
-
-      const statusColor =
-        {
-          running: chalk.green,
-          completed: chalk.green,
-          failed: chalk.red,
-          stale: chalk.yellow,
-        }[status] || chalk.dim;
-
-      const age = getAge(task.createdAt);
-      const timestamp = new Date(task.createdAt).toLocaleString();
-
-      console.log(
-        `${statusColor('●')} ${chalk.cyan(task.id)} ${statusColor(`[${status}]`)} ${chalk.dim(age + ' • ' + timestamp)}`
-      );
-      console.log(`  ${chalk.dim('CWD:')} ${task.cwd}`);
-      console.log(`  ${chalk.dim('Prompt:')} ${task.prompt}`);
-      if (task.pid && status === 'running') {
-        console.log(`  ${chalk.dim('PID:')} ${task.pid}`);
-      }
-      if (task.error) {
-        console.log(`  ${chalk.red('Error:')} ${task.error}`);
-      }
-      console.log();
+function printVerboseTasks(selected, total) {
+  console.log(chalk.bold(`\nTasks (${selected.length}/${total})\n`));
+
+  for (const { task, effectiveStatus } of selected) {
+    const statusColor = colorForStatus(effectiveStatus.status);
+    const age = getAge(task.createdAt);
+    const timestamp = new Date(task.createdAt).toLocaleString();
+
+    const heading = `${statusColor('●')} ${chalk.cyan(task.id)}`;
+    const status = statusColor(`[${effectiveStatus.status}]`);
+    const timing = chalk.dim(age + ' • ' + timestamp);
+    console.log(`${heading} ${status} ${timing}`);
+    console.log(`  ${chalk.dim('CWD:')} ${task.cwd}`);
+    console.log(`  ${chalk.dim('Prompt:')} ${task.prompt}`);
+    if (task.pid && effectiveStatus.status === 'running') {
+      console.log(`  ${chalk.dim('PID:')} ${task.pid}`);
     }
-  } else {
-    // Table format (clean, default)
-    console.log(chalk.bold(`\n=== Tasks (${filtered.length}/${taskList.length}) ===`));
-    console.log(`${'ID'.padEnd(25)} ${'Status'.padEnd(12)} ${'Age'.padEnd(10)} CWD`);
-    console.log('-'.repeat(100));
-
-    for (const task of filtered) {
-      // Verify running status
-      let status = task.status;
-      if (status === 'running' && !isProcessRunning(task.pid)) {
-        status = 'stale';
-      }
-
-      const statusColor =
-        {
-          running: chalk.green,
-          completed: chalk.green,
-          failed: chalk.red,
-          stale: chalk.yellow,
-        }[status] || chalk.dim;
-
-      const age = getAge(task.createdAt);
-      const cwd = task.cwd.replace(process.env.HOME, '~');
-
-      console.log(
-        `${chalk.cyan(task.id.padEnd(25))} ${statusColor(status.padEnd(12))} ${chalk.dim(age.padEnd(10))} ${chalk.dim(cwd)}`
-      );
+    if (task.error) {
+      console.log(`  ${chalk.red('Error:')} ${task.error}`);
     }
     console.log();
   }
 }
 
+function printTaskTable(selected, total) {
+  console.log(chalk.bold(`\n=== Tasks (${selected.length}/${total}) ===`));
+  console.log(`${'ID'.padEnd(25)} ${'Status'.padEnd(12)} ${'Age'.padEnd(10)} CWD`);
+  console.log('-'.repeat(100));
+
+  for (const { task, effectiveStatus } of selected) {
+    const statusColor = colorForStatus(effectiveStatus.status);
+    const age = getAge(task.createdAt);
+    const cwd = process.env.HOME ? task.cwd.replace(process.env.HOME, '~') : task.cwd;
+
+    const id = chalk.cyan(task.id.padEnd(25));
+    const status = statusColor(effectiveStatus.status.padEnd(12));
+    const timing = chalk.dim(age.padEnd(10));
+    console.log(`${id} ${status} ${timing} ${chalk.dim(cwd)}`);
+  }
+  console.log();
+}
+
+function colorForStatus(status) {
+  return (
+    {
+      running: chalk.green,
+      completed: chalk.green,
+      failed: chalk.red,
+      stale: chalk.yellow,
+    }[status] || chalk.dim
+  );
+}
+
 function getAge(dateStr) {
   const diff = Date.now() - new Date(dateStr).getTime();
   const mins = Math.floor(diff / 60000);