@the-open-engine/zeroshot 6.32.0 → 6.33.0

package/lib/target/discovery.js

@@ -33,52 +33,27 @@ const ROOT_FIELDS = [
     'transport',
     'extensions',
 ];
-async function readBoundedJson(response) {
-    return (0, bounded_response_js_1.readBoundedResponseJson)(response, MAX_DISCOVERY_BYTES, (kind) => new discovery_errors_js_1.TargetDiscoveryError(kind === 'size' ? 'response exceeds the size limit' : 'response is not valid UTF-8 JSON'));
-}
-async function fetchDocument(http, url) {
-    const response = await http.fetch(url, {
-        method: 'GET',
-        headers: { Accept: 'application/json' },
-        redirect: 'error',
-    });
-    if (response.url && new URL(response.url).href !== url) {
-        await response.body?.cancel().catch(() => undefined);
-        throw new discovery_errors_js_1.TargetDiscoveryError('request changed target route or authority');
-    }
-    if (!response.ok) {
-        await response.body?.cancel().catch(() => undefined);
-        throw new discovery_errors_js_1.TargetDiscoveryError(`request failed with status ${response.status}`);
-    }
-    return (0, discovery_validation_js_1.record)(await readBoundedJson(response), 'response');
-}
-async function discoverTarget(targetUrl, http) {
-    const target = new URL(targetUrl);
-    const origin = target.origin;
-    const discovery = await fetchDocument(http, new URL(DISCOVERY_PATH, target).href);
+const FLAGS = [
+    'capsule_allocate',
+    'capsule_read',
+    'capsule_terminate',
+    'capsule_access',
+    'connections_onboarding',
+];
+const SIZE_ERROR = 'response exceeds the size limit';
+const JSON_ERROR = 'response is not valid UTF-8 JSON';
+function parseDiscoveryDocument(discovery, origin) {
     (0, discovery_validation_js_1.exact)(discovery.kind, 'openengine.hosted-target/v1', 'kind');
     const adapter = (0, discovery_sections_js_1.parseAdapter)(discovery);
     const endpoint = (0, discovery_sections_js_1.parseEndpoint)(discovery, origin);
     const capsule = (0, discovery_sections_js_1.parseCapsule)(discovery, origin);
     const oauth = (0, discovery_sections_js_1.parseOAuth)(discovery, origin);
     (0, discovery_validation_js_1.exact)(discovery.organization_binding, 'device_approval', 'organization_binding');
-    const capabilityFlags = (0, discovery_validation_js_1.exactStringSet)(discovery.capability_flags, 'capability_flags', [
-        'capsule_allocate',
-        'capsule_read',
-        'capsule_terminate',
-        'capsule_access',
-        'connections_onboarding',
-    ]);
+    const capabilityFlags = (0, discovery_validation_js_1.exactStringSet)(discovery.capability_flags, 'capability_flags', FLAGS);
     const sizes = (0, discovery_sections_js_1.parseSizes)(discovery);
     const session = (0, discovery_sections_js_1.parseSession)(discovery);
     const transport = (0, discovery_sections_js_1.parseTransport)(discovery);
-    const credentialInstall = (0, discovery_sections_js_1.parseExtensions)(discovery, origin);
-    const metadata = await fetchDocument(http, oauth.metadataUrl);
-    (0, discovery_sections_js_1.validateOAuthMetadata)(metadata, origin, [
-        oauth.deviceAuthorizationEndpoint,
-        oauth.tokenEndpoint,
-        oauth.revocationEndpoint,
-    ]);
+    const extensions = (0, discovery_sections_js_1.parseExtensions)(discovery, origin);
     const additional = Object.freeze(Object.fromEntries(Object.entries(discovery).filter(([key]) => !ROOT_FIELDS.includes(key))));
     return Object.freeze({
         origin,
@@ -92,10 +67,24 @@ async function discoverTarget(targetUrl, http) {
         capsule,
         transport,
         capabilityFlags,
-        credentialInstall,
+        credentialInstall: extensions.credentialInstall,
+        runIntent: extensions.runIntent,
         additional,
     });
 }
+async function discoverTarget(targetUrl, http) {
+    const target = new URL(targetUrl);
+    const origin = target.origin;
+    const discovery = await fetchDocument(http, new URL(DISCOVERY_PATH, target).href);
+    const descriptor = parseDiscoveryDocument(discovery, origin);
+    const metadata = await fetchDocument(http, descriptor.oauth.metadataUrl);
+    (0, discovery_sections_js_1.validateOAuthMetadata)(metadata, origin, [
+        descriptor.oauth.deviceAuthorizationEndpoint,
+        descriptor.oauth.tokenEndpoint,
+        descriptor.oauth.revocationEndpoint,
+    ]);
+    return descriptor;
+}
 async function discoverTargetSessionEndpoints(targetUrl, http) {
     const descriptor = await discoverTarget(targetUrl, http);
     return Object.freeze({
@@ -110,3 +99,25 @@ async function discoverTargetSessionEndpoints(targetUrl, http) {
         descriptor,
     });
 }
+function boundedResponseError(kind) {
+    return new discovery_errors_js_1.TargetDiscoveryError(kind === 'size' ? SIZE_ERROR : JSON_ERROR);
+}
+async function readBoundedJson(response) {
+    return (0, bounded_response_js_1.readBoundedResponseJson)(response, MAX_DISCOVERY_BYTES, boundedResponseError);
+}
+async function fetchDocument(http, url) {
+    const response = await http.fetch(url, {
+        method: 'GET',
+        headers: { Accept: 'application/json' },
+        redirect: 'error',
+    });
+    if (response.url && new URL(response.url).href !== url) {
+        await response.body?.cancel().catch(() => undefined);
+        throw new discovery_errors_js_1.TargetDiscoveryError('request changed target route or authority');
+    }
+    if (!response.ok) {
+        await response.body?.cancel().catch(() => undefined);
+        throw new discovery_errors_js_1.TargetDiscoveryError(`request failed with status ${response.status}`);
+    }
+    return (0, discovery_validation_js_1.record)(await readBoundedJson(response), 'response');
+}

package/lib/target/discovery.mjs

@@ -26,52 +26,27 @@ const ROOT_FIELDS = [
     'transport',
     'extensions',
 ];
-async function readBoundedJson(response) {
-    return readBoundedResponseJson(response, MAX_DISCOVERY_BYTES, (kind) => new TargetDiscoveryError(kind === 'size' ? 'response exceeds the size limit' : 'response is not valid UTF-8 JSON'));
-}
-async function fetchDocument(http, url) {
-    const response = await http.fetch(url, {
-        method: 'GET',
-        headers: { Accept: 'application/json' },
-        redirect: 'error',
-    });
-    if (response.url && new URL(response.url).href !== url) {
-        await response.body?.cancel().catch(() => undefined);
-        throw new TargetDiscoveryError('request changed target route or authority');
-    }
-    if (!response.ok) {
-        await response.body?.cancel().catch(() => undefined);
-        throw new TargetDiscoveryError(`request failed with status ${response.status}`);
-    }
-    return record(await readBoundedJson(response), 'response');
-}
-export async function discoverTarget(targetUrl, http) {
-    const target = new URL(targetUrl);
-    const origin = target.origin;
-    const discovery = await fetchDocument(http, new URL(DISCOVERY_PATH, target).href);
+const FLAGS = [
+    'capsule_allocate',
+    'capsule_read',
+    'capsule_terminate',
+    'capsule_access',
+    'connections_onboarding',
+];
+const SIZE_ERROR = 'response exceeds the size limit';
+const JSON_ERROR = 'response is not valid UTF-8 JSON';
+function parseDiscoveryDocument(discovery, origin) {
     exact(discovery.kind, 'openengine.hosted-target/v1', 'kind');
     const adapter = parseAdapter(discovery);
     const endpoint = parseEndpoint(discovery, origin);
     const capsule = parseCapsule(discovery, origin);
     const oauth = parseOAuth(discovery, origin);
     exact(discovery.organization_binding, 'device_approval', 'organization_binding');
-    const capabilityFlags = exactStringSet(discovery.capability_flags, 'capability_flags', [
-        'capsule_allocate',
-        'capsule_read',
-        'capsule_terminate',
-        'capsule_access',
-        'connections_onboarding',
-    ]);
+    const capabilityFlags = exactStringSet(discovery.capability_flags, 'capability_flags', FLAGS);
     const sizes = parseSizes(discovery);
     const session = parseSession(discovery);
     const transport = parseTransport(discovery);
-    const credentialInstall = parseExtensions(discovery, origin);
-    const metadata = await fetchDocument(http, oauth.metadataUrl);
-    validateOAuthMetadata(metadata, origin, [
-        oauth.deviceAuthorizationEndpoint,
-        oauth.tokenEndpoint,
-        oauth.revocationEndpoint,
-    ]);
+    const extensions = parseExtensions(discovery, origin);
     const additional = Object.freeze(Object.fromEntries(Object.entries(discovery).filter(([key]) => !ROOT_FIELDS.includes(key))));
     return Object.freeze({
         origin,
@@ -85,10 +60,24 @@ export async function discoverTarget(targetUrl, http) {
         capsule,
         transport,
         capabilityFlags,
-        credentialInstall,
+        credentialInstall: extensions.credentialInstall,
+        runIntent: extensions.runIntent,
         additional,
     });
 }
+export async function discoverTarget(targetUrl, http) {
+    const target = new URL(targetUrl);
+    const origin = target.origin;
+    const discovery = await fetchDocument(http, new URL(DISCOVERY_PATH, target).href);
+    const descriptor = parseDiscoveryDocument(discovery, origin);
+    const metadata = await fetchDocument(http, descriptor.oauth.metadataUrl);
+    validateOAuthMetadata(metadata, origin, [
+        descriptor.oauth.deviceAuthorizationEndpoint,
+        descriptor.oauth.tokenEndpoint,
+        descriptor.oauth.revocationEndpoint,
+    ]);
+    return descriptor;
+}
 export async function discoverTargetSessionEndpoints(targetUrl, http) {
     const descriptor = await discoverTarget(targetUrl, http);
     return Object.freeze({
@@ -103,3 +92,25 @@ export async function discoverTargetSessionEndpoints(targetUrl, http) {
         descriptor,
     });
 }
+function boundedResponseError(kind) {
+    return new TargetDiscoveryError(kind === 'size' ? SIZE_ERROR : JSON_ERROR);
+}
+async function readBoundedJson(response) {
+    return readBoundedResponseJson(response, MAX_DISCOVERY_BYTES, boundedResponseError);
+}
+async function fetchDocument(http, url) {
+    const response = await http.fetch(url, {
+        method: 'GET',
+        headers: { Accept: 'application/json' },
+        redirect: 'error',
+    });
+    if (response.url && new URL(response.url).href !== url) {
+        await response.body?.cancel().catch(() => undefined);
+        throw new TargetDiscoveryError('request changed target route or authority');
+    }
+    if (!response.ok) {
+        await response.body?.cancel().catch(() => undefined);
+        throw new TargetDiscoveryError(`request failed with status ${response.status}`);
+    }
+    return record(await readBoundedJson(response), 'response');
+}

package/lib/target/index.d.ts

@@ -3,4 +3,4 @@ export { acquireTargetLock } from './credential-lock.js';
 export { requestDeviceCode, pollForToken, parseTokenResponse, DeviceFlowDeniedError, DeviceFlowExpiredError, UnboundSessionError, type DeviceCodeResponse, type DeviceExchangeContext, type TokenResponse, type HttpTransport, type Clock, } from './device-flow.js';
 export { addTarget, removeTarget, getTarget, listTargets, updateTargetOrganization, validateTargetName, normalizeAndValidateUrl, TargetNameInvalidError, TargetNameExistsError, TargetNotFoundError, TargetUrlInvalidError, type TargetRecord, type SettingsPort, } from './target-registry.js';
 export { TargetSessionManager, LoginRequiredError, type BrowserOpener, type TargetSessionDeps, type TargetSessionManagerInit, } from './target-session.js';
-export { discoverTarget, discoverTargetSessionEndpoints, expandRoute, TargetDiscoveryError, type CredentialInstallDescriptor, type RouteTemplate, type TargetDiscoveryDescriptor, type TargetSessionEndpoints, } from './discovery.js';
+export { discoverTarget, discoverTargetSessionEndpoints, expandRoute, TargetDiscoveryError, type CredentialInstallDescriptor, type RunIntentDescriptor, type RouteTemplate, type TargetDiscoveryDescriptor, type TargetSessionEndpoints, } from './discovery.js';

package/lib/target/run-intent-discovery.cjs

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseRunIntent = parseRunIntent;
+const route_template_js_1 = require("./route-template.cjs");
+const discovery_validation_js_1 = require("./discovery-validation.cjs");
+function parseRunIntent(value, origin) {
+    if (value === undefined || value === null)
+        return null;
+    const extension = (0, discovery_validation_js_1.closedRecord)(value, 'extensions.run_intent', [
+        'kind',
+        'base_url',
+        'route_templates',
+    ]);
+    (0, discovery_validation_js_1.exact)(extension.kind, 'zeroshot.run-intent/v2', 'extensions.run_intent.kind');
+    const routes = (0, discovery_validation_js_1.closedRecord)(extension.route_templates, 'extensions.run_intent.route_templates', [
+        'submit',
+        'status',
+        'cancel',
+    ]);
+    const route = (name, variables) => (0, route_template_js_1.routeTemplate)(routes[name], `extensions.run_intent.route_templates.${name}`, variables);
+    return Object.freeze({
+        kind: 'zeroshot.run-intent/v2',
+        baseUrl: (0, discovery_validation_js_1.sameOriginUrl)(extension.base_url, 'extensions.run_intent.base_url', origin),
+        routes: Object.freeze({
+            submit: route('submit', ['org_id']),
+            status: route('status', ['org_id', 'intent_id']),
+            cancel: route('cancel', ['org_id', 'intent_id']),
+        }),
+    });
+}

package/lib/target/run-intent-discovery.d.cts

@@ -0,0 +1,11 @@
+import type { RouteTemplate } from './route-template.js';
+export interface RunIntentDescriptor {
+    readonly kind: 'zeroshot.run-intent/v2';
+    readonly baseUrl: string;
+    readonly routes: {
+        readonly submit: RouteTemplate;
+        readonly status: RouteTemplate;
+        readonly cancel: RouteTemplate;
+    };
+}
+export declare function parseRunIntent(value: unknown, origin: string): RunIntentDescriptor | null;

package/lib/target/run-intent-discovery.d.mts

@@ -0,0 +1,11 @@
+import type { RouteTemplate } from './route-template.js';
+export interface RunIntentDescriptor {
+    readonly kind: 'zeroshot.run-intent/v2';
+    readonly baseUrl: string;
+    readonly routes: {
+        readonly submit: RouteTemplate;
+        readonly status: RouteTemplate;
+        readonly cancel: RouteTemplate;
+    };
+}
+export declare function parseRunIntent(value: unknown, origin: string): RunIntentDescriptor | null;

package/lib/target/run-intent-discovery.d.ts

@@ -0,0 +1,11 @@
+import type { RouteTemplate } from './route-template.js';
+export interface RunIntentDescriptor {
+    readonly kind: 'zeroshot.run-intent/v2';
+    readonly baseUrl: string;
+    readonly routes: {
+        readonly submit: RouteTemplate;
+        readonly status: RouteTemplate;
+        readonly cancel: RouteTemplate;
+    };
+}
+export declare function parseRunIntent(value: unknown, origin: string): RunIntentDescriptor | null;

package/lib/target/run-intent-discovery.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseRunIntent = parseRunIntent;
+const route_template_js_1 = require("./route-template.js");
+const discovery_validation_js_1 = require("./discovery-validation.js");
+function parseRunIntent(value, origin) {
+    if (value === undefined || value === null)
+        return null;
+    const extension = (0, discovery_validation_js_1.closedRecord)(value, 'extensions.run_intent', [
+        'kind',
+        'base_url',
+        'route_templates',
+    ]);
+    (0, discovery_validation_js_1.exact)(extension.kind, 'zeroshot.run-intent/v2', 'extensions.run_intent.kind');
+    const routes = (0, discovery_validation_js_1.closedRecord)(extension.route_templates, 'extensions.run_intent.route_templates', [
+        'submit',
+        'status',
+        'cancel',
+    ]);
+    const route = (name, variables) => (0, route_template_js_1.routeTemplate)(routes[name], `extensions.run_intent.route_templates.${name}`, variables);
+    return Object.freeze({
+        kind: 'zeroshot.run-intent/v2',
+        baseUrl: (0, discovery_validation_js_1.sameOriginUrl)(extension.base_url, 'extensions.run_intent.base_url', origin),
+        routes: Object.freeze({
+            submit: route('submit', ['org_id']),
+            status: route('status', ['org_id', 'intent_id']),
+            cancel: route('cancel', ['org_id', 'intent_id']),
+        }),
+    });
+}

package/lib/target/run-intent-discovery.mjs

@@ -0,0 +1,27 @@
+import { routeTemplate } from './route-template.mjs';
+import { closedRecord, exact, sameOriginUrl } from './discovery-validation.mjs';
+export function parseRunIntent(value, origin) {
+    if (value === undefined || value === null)
+        return null;
+    const extension = closedRecord(value, 'extensions.run_intent', [
+        'kind',
+        'base_url',
+        'route_templates',
+    ]);
+    exact(extension.kind, 'zeroshot.run-intent/v2', 'extensions.run_intent.kind');
+    const routes = closedRecord(extension.route_templates, 'extensions.run_intent.route_templates', [
+        'submit',
+        'status',
+        'cancel',
+    ]);
+    const route = (name, variables) => routeTemplate(routes[name], `extensions.run_intent.route_templates.${name}`, variables);
+    return Object.freeze({
+        kind: 'zeroshot.run-intent/v2',
+        baseUrl: sameOriginUrl(extension.base_url, 'extensions.run_intent.base_url', origin),
+        routes: Object.freeze({
+            submit: route('submit', ['org_id']),
+            status: route('status', ['org_id', 'intent_id']),
+            cancel: route('cancel', ['org_id', 'intent_id']),
+        }),
+    });
+}

package/npm-shrinkwrap.json

@@ -1,12 +1,12 @@
 {
   "name": "@the-open-engine/zeroshot",
-  "version": "6.32.0",
+  "version": "6.33.0",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "@the-open-engine/zeroshot",
-      "version": "6.32.0",
+      "version": "6.33.0",
       "hasInstallScript": true,
       "license": "MIT",
       "dependencies": {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@the-open-engine/zeroshot",
-  "version": "6.32.0",
+  "version": "6.33.0",
   "description": "Independent executor–verifier orchestration for software changes.",
   "main": "src/orchestrator.js",
   "bin": {
@@ -77,7 +77,6 @@
     "protocol:generate": "node scripts/generate-cluster-types.js",
     "protocol:check": "cargo run -p openengine-cluster-testkit --bin generate-cluster-protocol -- --check && node scripts/generate-cluster-types.js --check",
     "rust:distribution:check": "node scripts/rust-distribution.js check-repository",
-    "hosted-oecp:image:check": "node scripts/hosted-oecp-image.js check",
     "rust:check": "cargo fmt --all -- --check && cargo clippy --workspace --all-targets -- -D warnings && cargo test --workspace",
     "deadcode": "ts-prune --skip node_modules",
     "deadcode:files": "unimported",
@@ -177,8 +176,8 @@
     "!scripts/hosted-oecp-ci-relevance.js",
     "!scripts/hosted-oecp-image.js",
     "!scripts/hosted-oecp-image-commands.js",
+    "!scripts/hosted-oecp-image-inspection.js",
     "!scripts/hosted-oecp-image-smoke.js",
-    "!scripts/hosted-oecp-manifest.js",
     "!scripts/hosted-oecp-smoke-capability.js",
     "!scripts/hosted-oecp-smoke-client.js",
     "!scripts/hosted-oecp-smoke-codex.mjs",

package/src/agent/agent-lifecycle.js

@@ -24,6 +24,10 @@ const { findPlatformMismatchReason } = require('./validation-platform');
 const { calculateRateLimitDelay, isRateLimitError } = require('./rate-limit-backoff');
 const { updateAgentProviderSession } = require('./provider-session');
 const { rebuildProviderSessionAfterCommit } = require('./agent-task-executor');
+const {
+  buildStructuredOutputClusterFailure,
+  isStructuredOutputInvalidError,
+} = require('./structured-output-error');
 const {
   commitRecordedOwnership,
   markCleanupRequired,
@@ -735,6 +739,7 @@ async function handleFinalFailure(agent, triggeringMessage, error, maxRetries) {
   const failureAttempts = error?.terminationAttempts ?? maxRetries;
   const unsupportedCapability =
     error?.code === 'unsupported-capability' && error?.permanent === true;
+  const structuredOutputInvalid = isStructuredOutputInvalidError(error);
   console.error(`
 ${'='.repeat(80)}`);
   console.error(`🔴🔴🔴 MAX RETRIES EXHAUSTED - AGENT: ${agent.id} 🔴🔴🔴`);
@@ -810,6 +815,9 @@ ${'='.repeat(80)}`);
     });
   }
 
+  if (structuredOutputInvalid) {
+    agent._publish(buildStructuredOutputClusterFailure(agent, error));
+  }
   if (unsupportedCapability) {
     agent._publish({
       topic: 'CLUSTER_FAILED',
@@ -880,6 +888,7 @@ ${'='.repeat(80)}`);
           capability: error.capability,
         }
       : {}),
+    ...(structuredOutputInvalid ? { code: error.code, details: error.details ?? null } : {}),
     timestamp: Date.now(),
   };
 
@@ -910,6 +919,7 @@ ${'='.repeat(80)}`);
               capability: error.capability,
             }
           : {}),
+        ...(structuredOutputInvalid ? { code: error.code, details: error.details ?? null } : {}),
         hookFailureContext: error.message.includes('Hook uses result')
           ? {
               taskId: agent.currentTaskId || 'UNKNOWN',
@@ -936,7 +946,7 @@ ${'='.repeat(80)}`);
     orchestrator: agent.orchestrator,
   });
 
-  if (!error?.terminationExhausted && !unsupportedCapability) {
+  if (!error?.terminationExhausted && !unsupportedCapability && !structuredOutputInvalid) {
     agent.state = 'idle';
   }
 }

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

@@ -55,11 +55,12 @@ function detectCliFeatures(
   const help = helpText ?? '';
   const unknown = !help;
   const supportsConfigOverride = supports(help, /--config\b/);
+  const supportsSandbox = !unknown && /--sandbox\b/.test(help);
   return {
     provider: 'codex',
     supportsJson: supports(help, /--json\b/),
     supportsOutputSchema: supports(help, /--output-schema\b/),
-    supportsAutoApprove: supports(help, /--dangerously-bypass-approvals-and-sandbox\b/),
+    supportsAutoApprove: !unknown && supportsConfigOverride && supportsSandbox,
     supportsCwd: supports(help, /\s-C\b/) || supports(help, /--cwd\b/),
     supportsConfigOverride,
     supportsModel: supports(help, /\s-m\b/) || supports(help, /--model\b/),
@@ -67,7 +68,7 @@ function detectCliFeatures(
     supportsResume: supports(help, /\bresume\b/),
     supportsWebSearch:
       !unknown && supportsConfigOverride && isCliVersionAtLeast(versionText, '0.146.0'),
-    supportsSandbox: !unknown && /--sandbox\b/.test(help),
+    supportsSandbox,
     supportsEphemeral: !unknown && /--ephemeral\b/.test(help),
     supportsIgnoreUserConfig: !unknown && /--ignore-user-config\b/.test(help),
     supportsIgnoreRules: !unknown && /--ignore-rules\b/.test(help),
@@ -113,7 +114,9 @@ function addCwdArgs(args: string[], options: BuildProviderCommandOptions): void
 function addAutoApproveArgs(args: string[], options: BuildProviderCommandOptions): void {
   const features = optionFeatures(options);
   if (options.autoApprove && features.supportsAutoApprove) {
-    args.push('--dangerously-bypass-approvals-and-sandbox');
+    const sandboxMode =
+      options.executionContext === 'docker' ? 'danger-full-access' : 'workspace-write';
+    args.push('--sandbox', sandboxMode, '--config', 'approval_policy="never"');
   }
 }
 
@@ -166,7 +169,7 @@ function collectWarnings(options: BuildProviderCommandOptions): WarningMetadata[
       warning(
         'codex',
         'codex-auto-approve',
-        'Codex CLI does not support auto-approve; continuing without bypass flag.'
+        'Codex CLI does not support unattended workspace-write mode; continuing without it.'
       )
     );
   }
@@ -255,7 +258,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 +289,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 };
 }