@the-open-engine/zeroshot 6.17.0 → 6.19.0

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

@@ -9,6 +9,8 @@ import type {
   ProviderDocsMetadata,
   ProviderInvokeSpec,
   ProviderRegistryEntry,
+  StructuredOutputProviderRegistryEntry,
+  UnstructuredOutputProviderRegistryEntry,
 } from './provider-registry';
 
 export type ProviderId = (typeof providerIds)[number];
@@ -27,8 +29,9 @@ export type {
   ProviderDocsMetadata,
   ProviderInvokeSpec,
   ProviderRegistryEntry,
+  StructuredOutputProviderRegistryEntry,
+  UnstructuredOutputProviderRegistryEntry,
 };
-
 export interface AgentCliProviderHelperMetadata {
   readonly packageName: '@the-open-engine/zeroshot';
   readonly buildOutputDir: 'lib/agent-cli-provider';
@@ -105,6 +108,9 @@ export interface ClaudeCliFeatures extends BaseCliFeatures {
   readonly supportsSettings: boolean;
   readonly supportsMcpConfig: boolean;
   readonly supportsResume: boolean;
+  readonly supportsTools: boolean;
+  readonly supportsStrictMcpConfig: boolean;
+  readonly supportsNoSessionPersistence: boolean;
 }
 
 export interface CodexCliFeatures extends BaseCliFeatures {
@@ -118,6 +124,11 @@ export interface CodexCliFeatures extends BaseCliFeatures {
   readonly supportsSkipGitRepoCheck: boolean;
   readonly supportsResume: boolean;
   readonly supportsWebSearch: boolean;
+  readonly supportsSandbox: boolean;
+  readonly supportsEphemeral: boolean;
+  readonly supportsIgnoreUserConfig: boolean;
+  readonly supportsIgnoreRules: boolean;
+  readonly supportsStrictConfig: boolean;
 }
 
 export interface GeminiCliFeatures extends BaseCliFeatures {
@@ -126,6 +137,7 @@ export interface GeminiCliFeatures extends BaseCliFeatures {
   readonly supportsAutoApprove: boolean;
   readonly supportsCwd: boolean;
   readonly supportsModel: boolean;
+  readonly supportsAdminPolicy: boolean;
 }
 
 export interface OpencodeCliFeatures extends BaseCliFeatures {
@@ -138,6 +150,8 @@ export interface OpencodeCliFeatures extends BaseCliFeatures {
   readonly supportsAutoApprove: false;
   readonly supportsResume: boolean;
   readonly supportsWebSearch: boolean;
+  readonly supportsAgent: boolean;
+  readonly supportsRecoveryIsolation: boolean;
 }
 
 export interface PiCliFeatures extends BaseCliFeatures {
@@ -215,6 +229,9 @@ export interface CliFeatureOverrides {
   readonly supportsIncludePartials?: boolean;
   readonly supportsVerbose?: boolean;
   readonly supportsModel?: boolean;
+  readonly supportsTools?: boolean;
+  readonly supportsStrictMcpConfig?: boolean;
+  readonly supportsNoSessionPersistence?: boolean;
   readonly supportsEffort?: boolean;
   readonly supportsSettings?: boolean;
   readonly supportsJson?: boolean;
@@ -223,12 +240,20 @@ export interface CliFeatureOverrides {
   readonly supportsCwd?: boolean;
   readonly supportsConfigOverride?: boolean;
   readonly supportsSkipGitRepoCheck?: boolean;
+  readonly supportsSandbox?: boolean;
+  readonly supportsEphemeral?: boolean;
+  readonly supportsIgnoreUserConfig?: boolean;
+  readonly supportsIgnoreRules?: boolean;
+  readonly supportsStrictConfig?: boolean;
   readonly supportsVariant?: boolean;
+  readonly supportsAdminPolicy?: boolean;
   readonly supportsJsonMode?: boolean;
   readonly supportsNoSession?: boolean;
   readonly supportsNoExtensions?: boolean;
   readonly supportsNoSkills?: boolean;
   readonly supportsNoPromptTemplates?: boolean;
+  readonly supportsAgent?: boolean;
+  readonly supportsRecoveryIsolation?: boolean;
   readonly supportsNoContextFiles?: boolean;
   readonly supportsNoApprove?: boolean;
   readonly supportsModeJson?: boolean;
@@ -262,7 +287,7 @@ export interface CleanupMetadata {
   readonly kind: 'temp-file' | 'temp-directory';
   readonly provider: ProviderId;
   readonly path: string;
-  readonly reason: 'output-schema' | 'settings-overlay';
+  readonly reason: 'output-schema' | 'settings-overlay' | 'admin-policy' | 'isolated-config';
 }
 
 export interface WarningMetadata {
@@ -312,6 +337,8 @@ export interface BuildProviderCommandOptions {
   // one variadic `--mcp-config` followed by file paths; adapters such as Copilot accept repeated
   // flags with inline JSON so configs survive container path translation.
   readonly mcpConfig?: readonly string[];
+  /** Internal profile for provider-neutral structured-output correction turns. */
+  readonly structuredOutputRecovery?: boolean;
 }
 
 export interface TextEvent {
@@ -415,6 +442,13 @@ export interface ProviderAdapter {
   classifyError(error: unknown): ErrorClassification;
 }
 
+export interface StructuredOutputRecoveryAdapter extends ProviderAdapter {
+  buildStructuredOutputRecoveryCommand(
+    context: string,
+    options?: BuildProviderCommandOptions
+  ): CommandSpec;
+}
+
 export class InvalidProviderModelError extends Error {
   readonly permanent = true;
 

package/src/agent-wrapper.js

@@ -13,7 +13,7 @@
 const LogicEngine = require('./logic-engine');
 const { validateAgentConfig } = require('./agent/agent-config');
 const { loadSettings, validateModelAgainstMax, VALID_MODELS } = require('../lib/settings');
-const { normalizeProviderName } = require('../lib/provider-names');
+const { normalizeProviderName, getDefaultProviderId } = require('../lib/provider-names');
 const { getProvider } = require('./providers');
 const { buildContext } = require('./agent/agent-context-builder');
 const { collectQueuedGuidance } = require('./agent/guidance-queue');
@@ -160,9 +160,9 @@ class AgentWrapper {
       this.config.provider ||
       clusterConfig.defaultProvider ||
       settings.defaultProvider ||
-      'claude';
+      getDefaultProviderId();
 
-    return normalizeProviderName(resolved) || 'claude';
+    return normalizeProviderName(resolved) || getDefaultProviderId();
   }
 
   _resolveModelSpec() {
@@ -586,8 +586,8 @@ class AgentWrapper {
    * Falls back to reformatting if extraction fails
    * @private
    */
-  _parseResultOutput(output) {
-    return parseResultOutput(this, output);
+  _parseResultOutput(output, options = {}) {
+    return parseResultOutput(this, output, options);
   }
 
   /**

package/src/claude-task-runner.js

@@ -9,7 +9,7 @@ const { spawn, spawnSync } = require('child_process');
 const fs = require('fs');
 const TaskRunner = require('./task-runner');
 const { loadSettings } = require('../lib/settings');
-const { normalizeProviderName } = require('../lib/provider-names');
+const { normalizeProviderName, getDefaultProviderId } = require('../lib/provider-names');
 const { getProvider } = require('./providers');
 const { prependWorktreeToolBinToEnv } = require('./worktree-tooling-env');
 const { applyDarwinKeychainBoundaryToEnv } = require('./darwin-keychain-boundary');
@@ -200,7 +200,9 @@ class ClaudeTaskRunner extends TaskRunner {
     } = options;
 
     const settings = loadSettings();
-    const providerName = normalizeProviderName(provider || settings.defaultProvider || 'claude');
+    const providerName = normalizeProviderName(
+      provider || settings.defaultProvider || getDefaultProviderId()
+    );
     const { providerModule, providerSettings, levelOverrides } = this._getProviderContext(
       providerName,
       settings
@@ -736,7 +738,7 @@ class ClaudeTaskRunner extends TaskRunner {
     rejectCallerSuppliedModelProvenance(options);
     const {
       agentId = 'unknown',
-      provider = 'claude',
+      provider = getDefaultProviderId(),
       model = null,
       modelLevel = null,
       modelSpec: explicitModelSpec = null,

package/src/cluster/errors.ts

@@ -13,6 +13,7 @@ export class ClusterInternalError extends ClusterError {}
 export class ClusterProtocolError extends ClusterError {}
 export class ClusterTransportError extends ClusterError {}
 export class ClusterTimeoutError extends ClusterError {}
+export class ClusterRequestError extends ClusterError {}
 
 export function requestAbortError(method: string): DOMException {
   return new DOMException(

package/src/cluster/index.ts

@@ -5,11 +5,15 @@ export {
   ClusterError,
   ClusterInternalError,
   ClusterProtocolError,
+  ClusterRequestError,
   ClusterRpcError,
   ClusterStateError,
   ClusterTimeoutError,
   ClusterTransportError,
 } from './errors.js';
+export { assertGraphProfile, assertGraphProfileSupported, assertGraphSpec } from './validators.js';
+export * from './payload-value.js';
+export * from './json-source.js';
 export { CONNECTION_TRANSITIONS, PROTOCOL_DIAGNOSTIC_CAPACITY, Connection } from './connection.js';
 export type {
   CallOptions,

package/src/cluster/json-source.ts

@@ -0,0 +1,71 @@
+import { ClusterRequestError } from './errors.js';
+import { MAX_FRAME_BYTES } from './generated/protocol.js';
+
+export const MAX_REQUEST_BYTES = MAX_FRAME_BYTES;
+
+export function decodeBoundedJson(bytes: Uint8Array): unknown {
+  if (bytes.length > MAX_REQUEST_BYTES) {
+    throw new ClusterRequestError(
+      `request payload of ${bytes.length} bytes exceeds the ${MAX_REQUEST_BYTES} byte limit`,
+      'OVERSIZED_JSON',
+    );
+  }
+  let text: string;
+  try {
+    text = new TextDecoder('utf-8', { fatal: true }).decode(bytes);
+  } catch {
+    throw new ClusterRequestError('request payload is not valid UTF-8', 'INVALID_UTF8');
+  }
+  try {
+    return JSON.parse(text) as unknown;
+  } catch {
+    throw new ClusterRequestError('request payload is not valid JSON', 'MALFORMED_JSON');
+  }
+}
+
+// Callers resolve `--graph`/`--input` specifiers ('-' vs. a file path) to a byte
+// source themselves; opening the filesystem stream stays outside src/cluster so this
+// module keeps no host-specific dependency (not even the `NodeJS` ambient namespace,
+// which isn't resolvable from a consumer's declaration-only install) beyond the
+// standard async-iterable protocol every Node Readable already implements — mirrors
+// how WebSocketLike is injected instead of importing 'ws' directly, see socket.ts.
+export async function readBoundedSource(
+  source: AsyncIterable<Uint8Array | string>,
+): Promise<Uint8Array> {
+  const encoder = new TextEncoder();
+  const chunks: Uint8Array[] = [];
+  let total = 0;
+  for await (const chunk of source) {
+    const bytes = typeof chunk === 'string' ? encoder.encode(chunk) : new Uint8Array(chunk);
+    total += bytes.length;
+    if (total > MAX_REQUEST_BYTES) {
+      throw new ClusterRequestError(
+        `request payload exceeds the ${MAX_REQUEST_BYTES} byte limit`,
+        'OVERSIZED_JSON',
+      );
+    }
+    chunks.push(bytes);
+  }
+  const assembled = new Uint8Array(total);
+  let offset = 0;
+  for (const bytes of chunks) {
+    assembled.set(bytes, offset);
+    offset += bytes.length;
+  }
+  return assembled;
+}
+
+export function assertDistinctRequestSources(
+  graph: string,
+  input: string | undefined,
+): asserts input is string {
+  if (input === undefined) {
+    throw new ClusterRequestError('--input is required for every hosted run', 'MISSING_INPUT');
+  }
+  if (graph === '-' && input === '-') {
+    throw new ClusterRequestError(
+      'graph and input cannot both read from stdin',
+      'AMBIGUOUS_STDIN_SOURCE',
+    );
+  }
+}

package/src/cluster/payload-value.ts

@@ -0,0 +1,84 @@
+import type { PayloadType } from './generated/protocol.js';
+import { ClusterRequestError } from './errors.js';
+
+export type InputValidationIssue = {
+  readonly path: string;
+  readonly code: 'TYPE_MISMATCH' | 'MISSING_REQUIRED_FIELD' | 'UNKNOWN_FIELD' | 'UNKNOWN_ENUM_LABEL';
+};
+
+type InternalIssue = InputValidationIssue & { readonly expectedKind: string };
+
+function isJsonInteger(value: unknown): boolean {
+  return typeof value === 'number' && Number.isFinite(value) && Number.isInteger(value);
+}
+
+function evaluate(type: PayloadType, value: unknown, path: string): InternalIssue | null {
+  switch (type.kind) {
+    case 'null':
+      return value === null ? null : { path, code: 'TYPE_MISMATCH', expectedKind: 'null' };
+    case 'boolean':
+      return typeof value === 'boolean' ? null : { path, code: 'TYPE_MISMATCH', expectedKind: 'boolean' };
+    case 'integer':
+      return isJsonInteger(value) ? null : { path, code: 'TYPE_MISMATCH', expectedKind: 'integer' };
+    case 'number':
+      return typeof value === 'number' && Number.isFinite(value)
+        ? null
+        : { path, code: 'TYPE_MISMATCH', expectedKind: 'number' };
+    case 'string':
+      return typeof value === 'string' ? null : { path, code: 'TYPE_MISMATCH', expectedKind: 'string' };
+    case 'enum':
+      if (typeof value !== 'string') return { path, code: 'TYPE_MISMATCH', expectedKind: 'enum' };
+      return type.values.includes(value)
+        ? null
+        : { path, code: 'UNKNOWN_ENUM_LABEL', expectedKind: 'enum' };
+    case 'array': {
+      if (!Array.isArray(value)) return { path, code: 'TYPE_MISMATCH', expectedKind: 'array' };
+      for (let index = 0; index < value.length; index += 1) {
+        const issue = evaluate(type.items, value[index], `${path}/${index}`);
+        if (issue) return issue;
+      }
+      return null;
+    }
+    case 'record': {
+      if (typeof value !== 'object' || value === null || Array.isArray(value)) {
+        return { path, code: 'TYPE_MISMATCH', expectedKind: 'record' };
+      }
+      const record = value as Readonly<Record<string, unknown>>;
+      const fieldNames = Object.keys(type.fields).sort();
+      for (const name of fieldNames) {
+        const field = type.fields[name];
+        if (!field) continue;
+        const fieldPath = `${path}/${name}`;
+        if (Object.prototype.hasOwnProperty.call(record, name)) {
+          const issue = evaluate(field.type, record[name], fieldPath);
+          if (issue) return issue;
+        } else if (field.required) {
+          return { path: fieldPath, code: 'MISSING_REQUIRED_FIELD', expectedKind: field.type.kind };
+        }
+      }
+      const declared = new Set(fieldNames);
+      const unknownField = Object.keys(record).sort().find((name) => !declared.has(name));
+      return unknownField
+        ? { path: `${path}/${unknownField}`, code: 'UNKNOWN_FIELD', expectedKind: 'record' }
+        : null;
+    }
+  }
+}
+
+export function firstInputValidationIssue(
+  type: PayloadType,
+  value: unknown,
+  path = '',
+): InputValidationIssue | null {
+  const issue = evaluate(type, value, path);
+  return issue ? { path: issue.path, code: issue.code } : null;
+}
+
+export function assertInputValue(type: PayloadType, value: unknown): void {
+  const issue = evaluate(type, value, '');
+  if (!issue) return;
+  throw new ClusterRequestError(
+    `input value at '${issue.path || '/'}' failed validation: ${issue.code}, expected ${issue.expectedKind}`,
+    'INVALID_INPUT',
+  );
+}

package/src/cluster/validators.ts

@@ -4,9 +4,9 @@ import {
   METHOD_RESULT_DEFINITIONS,
   PROTOCOL_VERSION,
 } from './generated/protocol.js';
-import type { ClusterMethod } from './generated/protocol.js';
+import type { ClusterMethod, GraphProfile, GraphSpec, ServerCapabilities } from './generated/protocol.js';
 import { CLUSTER_PROTOCOL_SCHEMA } from './generated/protocol-schema.js';
-import { ClusterProtocolError } from './errors.js';
+import { ClusterProtocolError, ClusterRequestError } from './errors.js';
 
 const ajv = new Ajv2020({
   allErrors: true,
@@ -54,3 +54,32 @@ export function assertMethodResult(method: ClusterMethod, value: unknown): void
     throw error;
   }
 }
+
+function assertRequestDefinition(definition: string, value: unknown, code: string): void {
+  const validate = validatorFor(definition);
+  if (validate(value)) return;
+  const details = (validate.errors ?? []).map((error) =>
+    `${error.instancePath || '/'} ${error.message ?? 'is invalid'}`
+  ).join('; ');
+  throw new ClusterRequestError(`${definition} validation failed: ${details}`, code);
+}
+
+export function assertGraphSpec(value: unknown): asserts value is GraphSpec {
+  assertRequestDefinition('GraphSpec', value, 'INVALID_GRAPH');
+}
+
+export function assertGraphProfile(value: unknown): asserts value is GraphProfile {
+  assertRequestDefinition('GraphProfile', value, 'INVALID_GRAPH_PROFILE');
+}
+
+export function assertGraphProfileSupported(
+  profile: GraphProfile,
+  capabilities: ServerCapabilities,
+): void {
+  if (!capabilities.graphProfiles?.includes(profile)) {
+    throw new ClusterRequestError(
+      `graph profile ${profile} is not among the server's advertised graphProfiles`,
+      'UNSUPPORTED_GRAPH_PROFILE',
+    );
+  }
+}

package/src/config-validator.js

@@ -14,6 +14,7 @@
 const { loadSettings } = require('../lib/settings');
 const {
   VALID_PROVIDERS,
+  getDefaultProviderId,
   normalizeProviderName,
   providerSupportsCapability,
 } = require('../lib/provider-names');
@@ -1987,8 +1988,8 @@ function resolveProviderName(agent, config, settings) {
     agent.provider ||
     config.defaultProvider ||
     settings.defaultProvider ||
-    'claude';
-  return normalizeProviderName(resolved) || 'claude';
+    getDefaultProviderId();
+  return normalizeProviderName(resolved) || getDefaultProviderId();
 }
 
 function validateProviderLevel(provider, requestedLevel, minLevel, maxLevel) {

package/src/isolation-manager.js

@@ -16,7 +16,11 @@ const os = require('os');
 const fs = require('fs');
 const { loadSettings } = require('../lib/settings');
 const { CLAUDE_AUTH_ENV_VARS, resolveClaudeAuth } = require('../lib/settings/claude-auth');
-const { normalizeProviderName, getProviderMetadata } = require('../lib/provider-names');
+const {
+  normalizeProviderName,
+  getProviderMetadata,
+  getDefaultProviderId,
+} = require('../lib/provider-names');
 const {
   MOUNT_PRESETS,
   resolveMounts,
@@ -236,7 +240,7 @@ class IsolationManager {
 
     const settings = loadSettings();
     const providerName = normalizeProviderName(
-      config.provider || settings.defaultProvider || 'claude'
+      config.provider || settings.defaultProvider || getDefaultProviderId()
     );
     const containerHome = config.containerHome || settings.dockerContainerHome || '/root';
 

package/src/orchestrator.js

@@ -46,7 +46,7 @@ const { generateName } = require('./name-generator');
 const configValidator = require('./config-validator');
 const TemplateResolver = require('./template-resolver');
 const { loadSettings } = require('../lib/settings');
-const { normalizeProviderName } = require('../lib/provider-names');
+const { normalizeProviderName, getDefaultProviderId } = require('../lib/provider-names');
 const { resolveRunPlan } = require('../lib/run-plan');
 const { isProcessRunning } = require('../lib/process-liveness');
 const { getProvider } = require('./providers');
@@ -270,6 +270,7 @@ class Orchestrator {
 
     // Track if orchestrator is closed (prevents _saveClusters race conditions during cleanup)
     this.closed = false;
+    this._conductorWatchdogs = new Set();
 
     // Track if clusters are loaded (for lazy loading pattern)
     this._clustersLoaded = options.skipLoad === true;
@@ -312,8 +313,8 @@ class Orchestrator {
       clusterConfig.forceProvider ||
       clusterConfig.defaultProvider ||
       settings.defaultProvider ||
-      'claude';
-    return normalizeProviderName(resolved) || 'claude';
+      getDefaultProviderId();
+    return normalizeProviderName(resolved) || getDefaultProviderId();
   }
 
   /**
@@ -1654,6 +1655,28 @@ class Orchestrator {
     const timeoutMs = 30000;
     let watchdogTimer = null;
     let completedAt = null;
+    const watchdog = {
+      clear: () => {
+        if (!watchdogTimer) {
+          return;
+        }
+        clearTimeout(watchdogTimer);
+        watchdogTimer = null;
+        this._conductorWatchdogs.delete(watchdog);
+        const elapsed = completedAt ? Date.now() - completedAt : 0;
+        this._log(
+          `✅ CLUSTER_OPERATIONS received (${elapsed}ms after conductor completed) - watchdog cleared`
+        );
+      },
+      dispose: () => {
+        if (watchdogTimer) {
+          clearTimeout(watchdogTimer);
+          watchdogTimer = null;
+        }
+        this._conductorWatchdogs.delete(watchdog);
+      },
+    };
+    this._conductorWatchdogs.add(watchdog);
 
     this._subscribeToClusterTopic(messageBus, clusterId, 'AGENT_LIFECYCLE', (message) => {
       const event = message.content?.data?.event;
@@ -1666,6 +1689,11 @@ class Orchestrator {
         );
 
         watchdogTimer = setTimeout(() => {
+          watchdogTimer = null;
+          this._conductorWatchdogs.delete(watchdog);
+          if (this.closed || messageBus._closed) {
+            return;
+          }
           const clusterOps = messageBus.query({
             cluster_id: clusterId,
             topic: 'CLUSTER_OPERATIONS',
@@ -1700,19 +1728,7 @@ class Orchestrator {
       }
     });
 
-    return {
-      clear: () => {
-        if (!watchdogTimer) {
-          return;
-        }
-        clearTimeout(watchdogTimer);
-        watchdogTimer = null;
-        const elapsed = completedAt ? Date.now() - completedAt : 0;
-        this._log(
-          `✅ CLUSTER_OPERATIONS received (${elapsed}ms after conductor completed) - watchdog cleared`
-        );
-      },
-    };
+    return watchdog;
   }
 
   _registerClusterOperationsHandler(
@@ -2414,6 +2430,10 @@ class Orchestrator {
       return;
     }
     this.closed = true;
+    for (const watchdog of this._conductorWatchdogs) {
+      watchdog.dispose();
+    }
+    this._conductorWatchdogs.clear();
 
     for (const cluster of this.clusters.values()) {
       if (typeof cluster.snapshotter?.stop === 'function') {

package/src/preflight.js

@@ -21,6 +21,7 @@ const {
 const { loadSettings, getClaudeCommand } = require('../lib/settings.js');
 const {
   VALID_PROVIDERS,
+  getDefaultProviderId,
   getProviderMetadata,
   normalizeProviderName,
   resolveProviderCommand,
@@ -597,7 +598,7 @@ async function runPreflight(options = {}) {
     };
   }
   const providerName = normalizeProviderName(
-    options.provider || settings.defaultProvider || 'claude'
+    options.provider || settings.defaultProvider || getDefaultProviderId()
   );
 
   const providerResult = validateProvider(providerName, options);

package/task-lib/attachable-watcher.js

@@ -111,6 +111,7 @@ const providerSessionCapture = createProviderSessionCapture({
   requestedSessionId: persistedTask?.requestedResumeSessionId || null,
   initialSessionId: persistedTask?.sessionId || null,
   initialSessionIdConflict: persistedTask?.sessionIdConflict === true,
+  disabled: config.structuredOutputRecovery === true,
 });
 let outputBuffer = '';
 

package/task-lib/command-spec-cleanup.js

@@ -14,6 +14,10 @@ const CLEANUP_METADATA_KEYS = ['kind', 'path', 'provider', 'reason'];
 const SCHEMA_DIRECTORY_PATTERN = /^zeroshot-schema-[A-Za-z0-9_-]+$/u;
 const SCHEMA_FILE_PATTERN =
   /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}\.json$/u;
+const POLICY_DIRECTORY_PATTERN = /^zeroshot-gemini-policy-[A-Za-z0-9_-]+$/u;
+const POLICY_FILE_PATTERN =
+  /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}\.toml$/u;
+const OPENCODE_CONFIG_DIRECTORY_PATTERN = /^zeroshot-opencode-config-[A-Za-z0-9_-]+$/u;
 
 function assertClosedCleanupMetadata(cleanupPath, metadata) {
   if (!metadata || typeof metadata !== 'object' || Array.isArray(metadata)) {
@@ -59,6 +63,37 @@ function createCleanupPlan(commandSpec) {
 }
 
 function assertOwnedTempDirectory(cleanupPath, metadata) {
+  const isOpenCodeConfig =
+    metadata.provider === 'opencode' && metadata.reason === 'isolated-config';
+  if (isOpenCodeConfig) {
+    const canonical =
+      isAbsolute(cleanupPath) &&
+      resolve(cleanupPath) === cleanupPath &&
+      dirname(cleanupPath) === resolve(tmpdir()) &&
+      OPENCODE_CONFIG_DIRECTORY_PATTERN.test(basename(cleanupPath));
+    if (!canonical) {
+      throw new Error(`Refusing unowned temporary directory cleanup: ${cleanupPath}`);
+    }
+    let stat;
+    try {
+      stat = lstatSync(cleanupPath);
+    } catch (error) {
+      if (error?.code === 'ENOENT') return true;
+      throw error;
+    }
+    const tempRoot = realpathSync(tmpdir());
+    const realDirectory = realpathSync(cleanupPath);
+    if (
+      stat.isSymbolicLink() ||
+      !stat.isDirectory() ||
+      dirname(realDirectory) !== tempRoot ||
+      basename(realDirectory) !== basename(cleanupPath)
+    ) {
+      throw new Error(`Refusing unowned temporary directory cleanup: ${cleanupPath}`);
+    }
+    return false;
+  }
+
   if (
     metadata.provider !== 'claude' ||
     metadata.reason !== 'settings-overlay' ||
@@ -79,22 +114,33 @@ function assertOwnedTempDirectory(cleanupPath, metadata) {
 }
 
 function assertCanonicalSchemaPath(cleanupPath, metadata) {
+  const isCodexSchema =
+    metadata.kind === 'temp-file' &&
+    metadata.provider === 'codex' &&
+    metadata.reason === 'output-schema';
+  const isGeminiPolicy =
+    metadata.kind === 'temp-file' &&
+    metadata.provider === 'gemini' &&
+    metadata.reason === 'admin-policy';
   if (
-    metadata.kind !== 'temp-file' ||
-    metadata.provider !== 'codex' ||
-    metadata.reason !== 'output-schema' ||
+    (!isCodexSchema && !isGeminiPolicy) ||
     !isAbsolute(cleanupPath) ||
     resolve(cleanupPath) !== cleanupPath
   ) {
-    throw new Error(`Refusing unowned output-schema cleanup: ${cleanupPath}`);
+    throw new Error(
+      `Refusing unowned ${isGeminiPolicy ? 'admin-policy' : 'output-schema'} cleanup: ${cleanupPath}`
+    );
   }
-  const schemaDirectory = dirname(cleanupPath);
-  if (
-    dirname(schemaDirectory) !== resolve(tmpdir()) ||
-    !SCHEMA_DIRECTORY_PATTERN.test(basename(schemaDirectory)) ||
-    !SCHEMA_FILE_PATTERN.test(basename(cleanupPath))
-  ) {
-    throw new Error(`Refusing non-canonical output-schema cleanup: ${cleanupPath}`);
+  const ownedDirectory = dirname(cleanupPath);
+  const matchesOwnedName = isCodexSchema
+    ? SCHEMA_DIRECTORY_PATTERN.test(basename(ownedDirectory)) &&
+      SCHEMA_FILE_PATTERN.test(basename(cleanupPath))
+    : POLICY_DIRECTORY_PATTERN.test(basename(ownedDirectory)) &&
+      POLICY_FILE_PATTERN.test(basename(cleanupPath));
+  if (dirname(ownedDirectory) !== resolve(tmpdir()) || !matchesOwnedName) {
+    throw new Error(
+      `Refusing non-canonical ${isGeminiPolicy ? 'admin-policy' : 'output-schema'} cleanup: ${cleanupPath}`
+    );
   }
 }
 

package/task-lib/commands/run.js

@@ -40,6 +40,7 @@ export async function runTask(prompt, options = {}) {
     jsonSchema,
     mcpConfig: options.mcpConfig,
     silentJsonOutput,
+    structuredOutputRecovery: options.structuredOutputRecovery === true,
   });
 
   console.log(chalk.green(`\n✓ Task spawned: ${chalk.cyan(task.id)}`));