@the-open-engine/zeroshot 6.33.1 → 6.34.1

package/lib/hosted-target/zero-cloud-v1-adapter.d.cts

@@ -10,4 +10,5 @@ export declare class ZeroCloudV1TargetAdapter implements TargetAdapter {
     terminate(capsuleId: string, signal?: AbortSignal): Promise<Capsule>;
     limits(signal?: AbortSignal): Promise<CapsuleLimits>;
     access(capsuleId: string, signal?: AbortSignal): Promise<CapsuleAccess>;
+    installRuntime(capsuleId: string, runtime: unknown, accessToken: string, signal?: AbortSignal): Promise<void>;
 }

package/lib/hosted-target/zero-cloud-v1-adapter.d.mts

@@ -10,4 +10,5 @@ export declare class ZeroCloudV1TargetAdapter implements TargetAdapter {
     terminate(capsuleId: string, signal?: AbortSignal): Promise<Capsule>;
     limits(signal?: AbortSignal): Promise<CapsuleLimits>;
     access(capsuleId: string, signal?: AbortSignal): Promise<CapsuleAccess>;
+    installRuntime(capsuleId: string, runtime: unknown, accessToken: string, signal?: AbortSignal): Promise<void>;
 }

package/lib/hosted-target/zero-cloud-v1-adapter.d.ts

@@ -10,4 +10,5 @@ export declare class ZeroCloudV1TargetAdapter implements TargetAdapter {
     terminate(capsuleId: string, signal?: AbortSignal): Promise<Capsule>;
     limits(signal?: AbortSignal): Promise<CapsuleLimits>;
     access(capsuleId: string, signal?: AbortSignal): Promise<CapsuleAccess>;
+    installRuntime(capsuleId: string, runtime: unknown, accessToken: string, signal?: AbortSignal): Promise<void>;
 }

package/lib/hosted-target/zero-cloud-v1-adapter.mjs

@@ -1,22 +1,14 @@
 import { IDEMPOTENCY_KEY_PATTERN, MAX_RESPONSE_BYTES } from './bounds.mjs';
-import { TargetAdapterError, TargetAuthError, TargetProtocolError, TargetTransportError, } from './errors.mjs';
+import { TargetProtocolError } from './errors.mjs';
 import { DefaultRetryPolicy } from './retry.mjs';
 import { assertCapsule, assertCapsuleAccess, assertCapsuleLimits, assertCapsuleListPage, } from './response-validation.mjs';
 import { readBoundedResponseJson } from '../target/bounded-response.mjs';
-import { throwCapsuleServerError } from './capsule-error-response.mjs';
 import { validateAccessUrl } from './access-url.mjs';
 import { withTargetRetry } from './retry-executor.mjs';
-import { requestUrl, } from './adapter-request.mjs';
-const DEFAULT_TRANSPORT = {
-    fetch(url, init) {
-        return globalThis.fetch(url, init);
-    },
-};
+import { installRuntime as installOpaqueRuntime } from './runtime-install.mjs';
+import { assertCapsuleResponseStatus } from './response-status.mjs';
+import { createAdapterRequester, } from './adapter-request.mjs';
 const DEFAULT_CLOCK = { now: () => Date.now() };
-function throwIfAborted(signal) {
-    if (signal?.aborted)
-        throw signal.reason ?? new globalThis.DOMException('The operation was aborted', 'AbortError');
-}
 function validOpaque(value, field) {
     if (value.length === 0 || value.length > 1024)
         throw new TargetProtocolError(`${field} is invalid`);
@@ -27,16 +19,14 @@ function jsonRequest(body) {
 export class ZeroCloudV1TargetAdapter {
     #descriptor;
     #organizationId;
-    #tokenProvider;
-    #transport;
+    #request;
     #clock;
     #retryPolicy;
     constructor(options) {
         this.#descriptor = options.descriptor;
         this.#organizationId = options.organization.id;
         validOpaque(this.#organizationId, 'organization id');
-        this.#tokenProvider = options.tokenProvider;
-        this.#transport = options.transport ?? DEFAULT_TRANSPORT;
+        this.#request = createAdapterRequester(options.descriptor, options.tokenProvider, options.transport);
         this.#clock = options.clock ?? DEFAULT_CLOCK;
         this.#retryPolicy = options.retryPolicy ?? new DefaultRetryPolicy();
     }
@@ -106,11 +96,33 @@ export class ZeroCloudV1TargetAdapter {
         validateAccessUrl(result.websocketUrl, capsuleId, this.#descriptor);
         return result;
     }
+    async installRuntime(capsuleId, runtime, accessToken, signal) {
+        const descriptor = this.#descriptor.credentialInstall;
+        if (descriptor === null) {
+            throw new TargetProtocolError('Target does not advertise runtime installation');
+        }
+        await installOpaqueRuntime({
+            capsuleId,
+            runtime,
+            accessToken,
+            descriptor,
+            ...(signal === undefined ? {} : { signal }),
+            clock: this.#clock,
+            retryPolicy: this.#retryPolicy,
+            request: (method, path, requestSignal, body, token) => this.#request({
+                method,
+                path,
+                signal: requestSignal,
+                request: { body },
+                accessToken: token,
+            }),
+        });
+    }
     #execute(...args) {
         return Promise.resolve().then(() => this.#executeExpanded(args));
     }
     #executeExpanded(args) {
-        const [operation, method, template, values, expectedStatus, validate, signal, request = {},] = args;
+        const [operation, method, template, values, expectedStatus, validate, signal, request = {}] = args;
         let path;
         try {
             path = template.expand(values);
@@ -119,60 +131,17 @@ export class ZeroCloudV1TargetAdapter {
             throw new TargetProtocolError('Capsule route expansion is unsafe');
         }
         return withTargetRetry(operation, async () => {
-            const response = await this.#request(method, path, signal, request);
-            if (response.status >= 300 && response.status < 400) {
-                await response.body?.cancel().catch(() => undefined);
-                throw new TargetProtocolError('Capsule redirects are forbidden');
-            }
-            if (response.status !== expectedStatus) {
-                if (response.status >= 200 && response.status < 300) {
-                    await response.body?.cancel().catch(() => undefined);
-                    throw new TargetProtocolError('Target returned an unexpected success status');
-                }
-                await throwCapsuleServerError(response, (errorResponse) => this.#readJson(errorResponse), this.#clock);
-            }
+            const response = await this.#request({
+                method,
+                path,
+                signal,
+                request,
+                accessToken: undefined,
+            });
+            await assertCapsuleResponseStatus(response, expectedStatus, (errorResponse) => this.#readJson(errorResponse), this.#clock);
             return validate(await this.#readJson(response));
         }, signal, { clock: this.#clock, policy: this.#retryPolicy });
     }
-    async #request(method, path, signal, request) {
-        throwIfAborted(signal);
-        const url = requestUrl(path, this.#descriptor);
-        let token;
-        try {
-            token = await this.#tokenProvider.getAccessToken(signal);
-        }
-        catch {
-            throw new TargetAuthError('Target access authorization failed');
-        }
-        const init = {
-            method,
-            headers: {
-                Accept: 'application/json',
-                Authorization: `Bearer ${token}`,
-                ...(request.body === undefined ? {} : { 'Content-Type': 'application/json' }),
-                ...request.headers,
-            },
-            redirect: 'manual',
-        };
-        if (request.body !== undefined)
-            init.body = request.body;
-        if (signal !== undefined)
-            init.signal = signal;
-        try {
-            const response = await this.#transport.fetch(url.href, init);
-            if (response.url && new globalThis.URL(response.url).href !== url.href) {
-                await response.body?.cancel().catch(() => undefined);
-                throw new TargetProtocolError('Capsule response changed target route');
-            }
-            return response;
-        }
-        catch (error) {
-            if (error instanceof TargetAdapterError)
-                throw error;
-            throwIfAborted(signal);
-            throw new TargetTransportError('Capsule transport failed');
-        }
-    }
     #readJson(response) {
         return readBoundedResponseJson(response, MAX_RESPONSE_BYTES, (kind) => new TargetProtocolError(kind === 'size'
             ? 'Capsule response exceeds the size limit'

package/lib/target/discovery-validation.cjs

@@ -81,29 +81,22 @@ function parseCredentialInstall(value) {
     if (value === undefined || value === null)
         return null;
     const extension = closedRecord(value, 'extensions.credential_install', [
-        'kind', 'grant', 'install', 'upload_url_origin', 'sealed_envelope_algorithms', 'bounds',
+        'kind',
+        'install',
+        'max_body_bytes',
     ]);
     exact(extension.kind, 'openengine.capsule-credential-install/v1', 'extensions.credential_install.kind');
-    const grant = closedRecord(extension.grant, 'extensions.credential_install.grant', ['route_template', 'method']);
-    const install = closedRecord(extension.install, 'extensions.credential_install.install', ['route_template', 'method']);
-    exact(grant.method, 'POST', 'extensions.credential_install.grant.method');
-    exact(install.method, 'PUT', 'extensions.credential_install.install.method');
-    exact(extension.upload_url_origin, 'same_origin', 'extensions.credential_install.upload_url_origin');
-    exactStringSet(extension.sealed_envelope_algorithms, 'extensions.credential_install.sealed_envelope_algorithms', ['RSA-OAEP-3072-SHA256']);
-    const bounds = closedRecord(extension.bounds, 'extensions.credential_install.bounds', [
-        'max_envelope_bytes', 'max_body_bytes', 'grant_ttl_seconds', 'max_clock_skew_seconds',
+    const install = closedRecord(extension.install, 'extensions.credential_install.install', [
+        'route_template',
+        'method',
     ]);
+    exact(install.method, 'PUT', 'extensions.credential_install.install.method');
     return Object.freeze({
         kind: 'openengine.capsule-credential-install/v1',
-        grant: Object.freeze({ routeTemplate: (0, route_template_js_1.routeTemplate)(grant.route_template, 'extensions.credential_install.grant.route_template', ['capsule_id']), method: 'POST' }),
-        install: Object.freeze({ routeTemplate: (0, route_template_js_1.routeTemplate)(install.route_template, 'extensions.credential_install.install.route_template', ['capsule_id']), method: 'PUT' }),
-        uploadUrlOrigin: 'same_origin',
-        sealedEnvelopeAlgorithms: Object.freeze(['RSA-OAEP-3072-SHA256']),
-        bounds: Object.freeze({
-            maxEnvelopeBytes: integer(bounds.max_envelope_bytes, 'extensions.credential_install.bounds.max_envelope_bytes', 1, 1_048_576),
-            maxBodyBytes: integer(bounds.max_body_bytes, 'extensions.credential_install.bounds.max_body_bytes', 1, 1_048_576),
-            grantTtlSeconds: integer(bounds.grant_ttl_seconds, 'extensions.credential_install.bounds.grant_ttl_seconds', 1, 3_600),
-            maxClockSkewSeconds: integer(bounds.max_clock_skew_seconds, 'extensions.credential_install.bounds.max_clock_skew_seconds', 0, 300),
+        install: Object.freeze({
+            routeTemplate: (0, route_template_js_1.routeTemplate)(install.route_template, 'extensions.credential_install.install.route_template', ['capsule_id']),
+            method: 'PUT',
         }),
+        maxBodyBytes: integer(extension.max_body_bytes, 'extensions.credential_install.max_body_bytes', 1, 4 * 1024 * 1024),
     });
 }

package/lib/target/discovery-validation.d.cts

@@ -1,22 +1,11 @@
 import { type RouteTemplate } from './route-template.js';
 export interface CredentialInstallDescriptor {
     readonly kind: 'openengine.capsule-credential-install/v1';
-    readonly grant: {
-        readonly routeTemplate: RouteTemplate;
-        readonly method: 'POST';
-    };
     readonly install: {
         readonly routeTemplate: RouteTemplate;
         readonly method: 'PUT';
     };
-    readonly uploadUrlOrigin: 'same_origin';
-    readonly sealedEnvelopeAlgorithms: readonly ['RSA-OAEP-3072-SHA256'];
-    readonly bounds: {
-        readonly maxEnvelopeBytes: number;
-        readonly maxBodyBytes: number;
-        readonly grantTtlSeconds: number;
-        readonly maxClockSkewSeconds: number;
-    };
+    readonly maxBodyBytes: number;
 }
 export declare function record(value: unknown, field: string): Record<string, unknown>;
 export declare function closedRecord(value: unknown, field: string, fields: readonly string[]): Record<string, unknown>;

package/lib/target/discovery-validation.d.mts

@@ -1,22 +1,11 @@
 import { type RouteTemplate } from './route-template.js';
 export interface CredentialInstallDescriptor {
     readonly kind: 'openengine.capsule-credential-install/v1';
-    readonly grant: {
-        readonly routeTemplate: RouteTemplate;
-        readonly method: 'POST';
-    };
     readonly install: {
         readonly routeTemplate: RouteTemplate;
         readonly method: 'PUT';
     };
-    readonly uploadUrlOrigin: 'same_origin';
-    readonly sealedEnvelopeAlgorithms: readonly ['RSA-OAEP-3072-SHA256'];
-    readonly bounds: {
-        readonly maxEnvelopeBytes: number;
-        readonly maxBodyBytes: number;
-        readonly grantTtlSeconds: number;
-        readonly maxClockSkewSeconds: number;
-    };
+    readonly maxBodyBytes: number;
 }
 export declare function record(value: unknown, field: string): Record<string, unknown>;
 export declare function closedRecord(value: unknown, field: string, fields: readonly string[]): Record<string, unknown>;

package/lib/target/discovery-validation.d.ts

@@ -1,22 +1,11 @@
 import { type RouteTemplate } from './route-template.js';
 export interface CredentialInstallDescriptor {
     readonly kind: 'openengine.capsule-credential-install/v1';
-    readonly grant: {
-        readonly routeTemplate: RouteTemplate;
-        readonly method: 'POST';
-    };
     readonly install: {
         readonly routeTemplate: RouteTemplate;
         readonly method: 'PUT';
     };
-    readonly uploadUrlOrigin: 'same_origin';
-    readonly sealedEnvelopeAlgorithms: readonly ['RSA-OAEP-3072-SHA256'];
-    readonly bounds: {
-        readonly maxEnvelopeBytes: number;
-        readonly maxBodyBytes: number;
-        readonly grantTtlSeconds: number;
-        readonly maxClockSkewSeconds: number;
-    };
+    readonly maxBodyBytes: number;
 }
 export declare function record(value: unknown, field: string): Record<string, unknown>;
 export declare function closedRecord(value: unknown, field: string, fields: readonly string[]): Record<string, unknown>;

package/lib/target/discovery-validation.js

@@ -81,29 +81,22 @@ function parseCredentialInstall(value) {
     if (value === undefined || value === null)
         return null;
     const extension = closedRecord(value, 'extensions.credential_install', [
-        'kind', 'grant', 'install', 'upload_url_origin', 'sealed_envelope_algorithms', 'bounds',
+        'kind',
+        'install',
+        'max_body_bytes',
     ]);
     exact(extension.kind, 'openengine.capsule-credential-install/v1', 'extensions.credential_install.kind');
-    const grant = closedRecord(extension.grant, 'extensions.credential_install.grant', ['route_template', 'method']);
-    const install = closedRecord(extension.install, 'extensions.credential_install.install', ['route_template', 'method']);
-    exact(grant.method, 'POST', 'extensions.credential_install.grant.method');
-    exact(install.method, 'PUT', 'extensions.credential_install.install.method');
-    exact(extension.upload_url_origin, 'same_origin', 'extensions.credential_install.upload_url_origin');
-    exactStringSet(extension.sealed_envelope_algorithms, 'extensions.credential_install.sealed_envelope_algorithms', ['RSA-OAEP-3072-SHA256']);
-    const bounds = closedRecord(extension.bounds, 'extensions.credential_install.bounds', [
-        'max_envelope_bytes', 'max_body_bytes', 'grant_ttl_seconds', 'max_clock_skew_seconds',
+    const install = closedRecord(extension.install, 'extensions.credential_install.install', [
+        'route_template',
+        'method',
     ]);
+    exact(install.method, 'PUT', 'extensions.credential_install.install.method');
     return Object.freeze({
         kind: 'openengine.capsule-credential-install/v1',
-        grant: Object.freeze({ routeTemplate: (0, route_template_js_1.routeTemplate)(grant.route_template, 'extensions.credential_install.grant.route_template', ['capsule_id']), method: 'POST' }),
-        install: Object.freeze({ routeTemplate: (0, route_template_js_1.routeTemplate)(install.route_template, 'extensions.credential_install.install.route_template', ['capsule_id']), method: 'PUT' }),
-        uploadUrlOrigin: 'same_origin',
-        sealedEnvelopeAlgorithms: Object.freeze(['RSA-OAEP-3072-SHA256']),
-        bounds: Object.freeze({
-            maxEnvelopeBytes: integer(bounds.max_envelope_bytes, 'extensions.credential_install.bounds.max_envelope_bytes', 1, 1_048_576),
-            maxBodyBytes: integer(bounds.max_body_bytes, 'extensions.credential_install.bounds.max_body_bytes', 1, 1_048_576),
-            grantTtlSeconds: integer(bounds.grant_ttl_seconds, 'extensions.credential_install.bounds.grant_ttl_seconds', 1, 3_600),
-            maxClockSkewSeconds: integer(bounds.max_clock_skew_seconds, 'extensions.credential_install.bounds.max_clock_skew_seconds', 0, 300),
+        install: Object.freeze({
+            routeTemplate: (0, route_template_js_1.routeTemplate)(install.route_template, 'extensions.credential_install.install.route_template', ['capsule_id']),
+            method: 'PUT',
         }),
+        maxBodyBytes: integer(extension.max_body_bytes, 'extensions.credential_install.max_body_bytes', 1, 4 * 1024 * 1024),
     });
 }

package/lib/target/discovery-validation.mjs

@@ -71,29 +71,22 @@ export function parseCredentialInstall(value) {
     if (value === undefined || value === null)
         return null;
     const extension = closedRecord(value, 'extensions.credential_install', [
-        'kind', 'grant', 'install', 'upload_url_origin', 'sealed_envelope_algorithms', 'bounds',
+        'kind',
+        'install',
+        'max_body_bytes',
     ]);
     exact(extension.kind, 'openengine.capsule-credential-install/v1', 'extensions.credential_install.kind');
-    const grant = closedRecord(extension.grant, 'extensions.credential_install.grant', ['route_template', 'method']);
-    const install = closedRecord(extension.install, 'extensions.credential_install.install', ['route_template', 'method']);
-    exact(grant.method, 'POST', 'extensions.credential_install.grant.method');
-    exact(install.method, 'PUT', 'extensions.credential_install.install.method');
-    exact(extension.upload_url_origin, 'same_origin', 'extensions.credential_install.upload_url_origin');
-    exactStringSet(extension.sealed_envelope_algorithms, 'extensions.credential_install.sealed_envelope_algorithms', ['RSA-OAEP-3072-SHA256']);
-    const bounds = closedRecord(extension.bounds, 'extensions.credential_install.bounds', [
-        'max_envelope_bytes', 'max_body_bytes', 'grant_ttl_seconds', 'max_clock_skew_seconds',
+    const install = closedRecord(extension.install, 'extensions.credential_install.install', [
+        'route_template',
+        'method',
     ]);
+    exact(install.method, 'PUT', 'extensions.credential_install.install.method');
     return Object.freeze({
         kind: 'openengine.capsule-credential-install/v1',
-        grant: Object.freeze({ routeTemplate: routeTemplate(grant.route_template, 'extensions.credential_install.grant.route_template', ['capsule_id']), method: 'POST' }),
-        install: Object.freeze({ routeTemplate: routeTemplate(install.route_template, 'extensions.credential_install.install.route_template', ['capsule_id']), method: 'PUT' }),
-        uploadUrlOrigin: 'same_origin',
-        sealedEnvelopeAlgorithms: Object.freeze(['RSA-OAEP-3072-SHA256']),
-        bounds: Object.freeze({
-            maxEnvelopeBytes: integer(bounds.max_envelope_bytes, 'extensions.credential_install.bounds.max_envelope_bytes', 1, 1_048_576),
-            maxBodyBytes: integer(bounds.max_body_bytes, 'extensions.credential_install.bounds.max_body_bytes', 1, 1_048_576),
-            grantTtlSeconds: integer(bounds.grant_ttl_seconds, 'extensions.credential_install.bounds.grant_ttl_seconds', 1, 3_600),
-            maxClockSkewSeconds: integer(bounds.max_clock_skew_seconds, 'extensions.credential_install.bounds.max_clock_skew_seconds', 0, 300),
+        install: Object.freeze({
+            routeTemplate: routeTemplate(install.route_template, 'extensions.credential_install.install.route_template', ['capsule_id']),
+            method: 'PUT',
         }),
+        maxBodyBytes: integer(extension.max_body_bytes, 'extensions.credential_install.max_body_bytes', 1, 4 * 1024 * 1024),
     });
 }

package/npm-shrinkwrap.json

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@the-open-engine/zeroshot",
-  "version": "6.33.1",
+  "version": "6.34.1",
   "description": "Independent executor–verifier orchestration for software changes.",
   "main": "src/orchestrator.js",
   "bin": {
@@ -44,6 +44,7 @@
     "typecheck:agent-cli-provider": "tsc --project tsconfig.agent-cli-provider.json",
     "typecheck:hosted-target": "tsc --project tsconfig.hosted-target.json",
     "typecheck:hosted-session": "tsc --project tsconfig.hosted-session.json",
+    "test:hosted": "npm run build:cluster && node --test tests/private-hosted-cli/*.test.js && npm run test:hosted-target",
     "test:hosted-target": "npm run build:cluster && npm run build:target && node --test tests/hosted-target/*.test.ts",
     "test:target": "npm run build:agent-cli-provider && npm run build:target && node --test tests/target/*.test.ts",
     "typecheck:target": "tsc --project tsconfig.target.json",

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

@@ -11,8 +11,10 @@
  */
 
 const { spawn, spawnSync } = require('child_process');
+const { createHash } = require('crypto');
 const path = require('path');
 const fs = require('fs');
+const { StringDecoder } = require('string_decoder');
 const { getNestedExecutionRegistry, TaskExecutionHandle } = require('./task-execution-handle');
 const os = require('os');
 const { parseProviderChunk, getProvider } = require('../providers');
@@ -57,6 +59,8 @@ const {
   isStructuredOutputInvalidError,
 } = require('./structured-output-error');
 const TASK_TERMINAL_STATUSES = new Set(['completed', 'failed', 'killed', 'stale']);
+const MAX_CONTROL_PLANE_RECORD_BYTES = 1024 * 1024;
+const LOG_READ_CHUNK_BYTES = 64 * 1024;
 function runCommandWithTimeout(command, args, options = {}, callback = null) {
   const timeout = options.timeout ?? 30000;
   if (timeout <= 0) {
@@ -1225,11 +1229,20 @@ function createLogFollowState() {
     pollInterval: null,
     statusCheckInterval: null,
     resolved: false,
-    lineBuffer: '',
+    lineBuffer: createLogRecordBuffer(),
+    logDecoder: new StringDecoder('utf8'),
     consecutiveExecFailures: 0,
   };
 }
 
+function createLogRecordBuffer() {
+  return {
+    byteLength: 0,
+    fragments: [],
+    oversized: null,
+  };
+}
+
 function lookupLogFilePath(ctPath, taskId) {
   try {
     return runCommandSync(ctPath, ['get-log-path', taskId], {
@@ -1310,15 +1323,82 @@ function broadcastAgentLine({ agent, providerName, state, line }) {
   });
 }
 
-function appendContentToBuffer(state, content, onLine) {
-  state.lineBuffer += content;
-  const lines = state.lineBuffer.split('\n');
+function appendLogRecordFragment(buffer, fragment) {
+  const fragmentBytes = Buffer.byteLength(fragment);
+  buffer.byteLength += fragmentBytes;
+  if (buffer.oversized) {
+    buffer.oversized.digest.update(fragment);
+    return;
+  }
+  if (buffer.byteLength <= MAX_CONTROL_PLANE_RECORD_BYTES) {
+    buffer.fragments.push(fragment);
+    return;
+  }
 
-  for (let i = 0; i < lines.length - 1; i++) {
-    onLine(lines[i]);
+  const retainedPrefix = buffer.fragments.join('');
+  const prefixProbe = `${retainedPrefix}${fragment.slice(0, Math.max(0, 32 - retainedPrefix.length))}`;
+  const timestampPrefix = prefixProbe.match(/^\[\d{13}\]/)?.[0] || '';
+  const digest = createHash('sha256');
+  for (const retained of buffer.fragments) digest.update(retained);
+  digest.update(fragment);
+  buffer.fragments = [];
+  buffer.oversized = { digest, timestampPrefix };
+}
+
+function completeLogRecord(buffer, onLine, skipEmpty = false) {
+  let line;
+  if (buffer.oversized) {
+    const digest = buffer.oversized.digest.digest('hex');
+    line =
+      `${buffer.oversized.timestampPrefix}[ZEROSHOT] Provider output record retained in task log ` +
+      `but omitted from the control plane (byte_length=${buffer.byteLength}, sha256=${digest})`;
+  } else {
+    line = buffer.fragments.join('');
   }
+  buffer.byteLength = 0;
+  buffer.fragments = [];
+  buffer.oversized = null;
+  if (!skipEmpty || line.trim()) onLine(line);
+}
 
-  state.lineBuffer = lines[lines.length - 1];
+function appendContentToBuffer(state, content, onLine, skipEmpty = false) {
+  let offset = 0;
+  while (offset < content.length) {
+    const newline = content.indexOf('\n', offset);
+    if (newline === -1) {
+      appendLogRecordFragment(state.lineBuffer, content.slice(offset));
+      return;
+    }
+    appendLogRecordFragment(state.lineBuffer, content.slice(offset, newline));
+    completeLogRecord(state.lineBuffer, onLine, skipEmpty);
+    offset = newline + 1;
+  }
+}
+
+function replayCompleteLogContent(content, onLine) {
+  const replayState = { lineBuffer: createLogRecordBuffer() };
+  appendContentToBuffer(replayState, content, onLine, true);
+  if (replayState.lineBuffer.byteLength > 0) {
+    completeLogRecord(replayState.lineBuffer, onLine, true);
+  }
+}
+
+function readLogFileDelta({ fsModule, logFilePath, state, currentSize, onNewContent }) {
+  const fd = fsModule.openSync(logFilePath, 'r');
+  try {
+    let offset = state.lastSize;
+    const buffer = Buffer.allocUnsafe(LOG_READ_CHUNK_BYTES);
+    while (offset < currentSize) {
+      const requested = Math.min(buffer.length, currentSize - offset);
+      const bytesRead = fsModule.readSync(fd, buffer, 0, requested, offset);
+      if (bytesRead === 0) break;
+      onNewContent(state.logDecoder.write(buffer.subarray(0, bytesRead)));
+      offset += bytesRead;
+    }
+    state.lastSize = offset;
+  } finally {
+    fsModule.closeSync(fd);
+  }
 }
 
 function pollLogFileForUpdates({ agent, fsModule, ctPath, taskId, state, onNewContent }) {
@@ -1340,13 +1420,13 @@ function pollLogFileForUpdates({ agent, fsModule, ctPath, taskId, state, onNewCo
     const currentSize = stats.size;
 
     if (currentSize > state.lastSize) {
-      const fd = fsModule.openSync(state.logFilePath, 'r');
-      const buffer = Buffer.alloc(currentSize - state.lastSize);
-      fsModule.readSync(fd, buffer, 0, buffer.length, state.lastSize);
-      fsModule.closeSync(fd);
-
-      onNewContent(buffer.toString('utf-8'));
-      state.lastSize = currentSize;
+      readLogFileDelta({
+        fsModule,
+        logFilePath: state.logFilePath,
+        state,
+        currentSize,
+        onNewContent,
+      });
     }
   } catch (err) {
     const error = /** @type {Error} */ (err);
@@ -2215,7 +2295,8 @@ function createIsolatedLogState(skipStructuredResultCheck = false, nested = fals
     tailProcess: null,
     statusCheckInterval: null,
     timeoutTimer: null,
-    lineBuffer: '',
+    lineBuffer: createLogRecordBuffer(),
+    tailDecoder: new StringDecoder('utf8'),
     skipStructuredResultCheck,
     nested,
   };
@@ -2376,9 +2457,7 @@ function settleIsolatedTerminalStatus({
 
     if (finalReadResult.code === 0 && finalReadResult.stdout) {
       state.fullOutput = finalReadResult.stdout;
-      for (const line of state.fullOutput.split('\n')) {
-        if (line.trim()) onLine(line);
-      }
+      replayCompleteLogContent(state.fullOutput, onLine);
     }
 
     const vertexModelError =
@@ -2566,16 +2645,14 @@ function broadcastIsolatedLine({ agent, providerName, taskId, state, line }) {
 }
 
 function appendIsolatedContent(state, content, onLine) {
-  state.lineBuffer += content;
-  const lines = state.lineBuffer.split('\n');
-
-  for (let i = 0; i < lines.length - 1; i++) {
-    if (lines[i].trim()) {
-      onLine(lines[i]);
-    }
-  }
+  appendContentToBuffer(state, content, onLine, true);
+}
 
-  state.lineBuffer = lines[lines.length - 1];
+function consumeIsolatedTailChunk(state, data, onLine) {
+  const chunk = typeof data === 'string' ? data : state.tailDecoder.write(data);
+  if (!chunk) return;
+  state.fullOutput += chunk;
+  appendIsolatedContent(state, chunk, onLine);
 }
 
 function startIsolatedTail({ agent, manager, clusterId, logFilePath, state, onLine }) {
@@ -2586,9 +2663,7 @@ function startIsolatedTail({ agent, manager, clusterId, logFilePath, state, onLi
   ]);
 
   state.tailProcess.stdout.on('data', (data) => {
-    const chunk = data.toString();
-    state.fullOutput += chunk;
-    appendIsolatedContent(state, chunk, onLine);
+    consumeIsolatedTailChunk(state, data, onLine);
   });
 
   state.tailProcess.stderr.on('data', (data) => {
@@ -2599,6 +2674,7 @@ function startIsolatedTail({ agent, manager, clusterId, logFilePath, state, onLi
   });
 
   state.tailProcess.on('close', (exitCode) => {
+    consumeIsolatedTailChunk(state, state.tailDecoder.end(), onLine);
     if (!state.taskExited) {
       agent._log(`[${agent.id}] tail process exited with code ${exitCode}`);
     }
@@ -3091,4 +3167,7 @@ module.exports = {
   buildTaskRunArgs,
   rebuildProviderSessionAfterCommit,
   killTask,
+  createLogRecordBuffer,
+  appendContentToBuffer,
+  consumeIsolatedTailChunk,
 };

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

@@ -115,7 +115,9 @@ function addAutoApproveArgs(args: string[], options: BuildProviderCommandOptions
   const features = optionFeatures(options);
   if (options.autoApprove && features.supportsAutoApprove) {
     const sandboxMode =
-      options.executionContext === 'docker' ? 'danger-full-access' : 'workspace-write';
+      options.executionContext === 'docker' || options.executionContext === 'benchmark'
+        ? 'danger-full-access'
+        : 'workspace-write';
     args.push('--sandbox', sandboxMode, '--config', 'approval_policy="never"');
   }
 }