@the-open-engine/zeroshot 6.7.1 → 6.8.0

package/src/orchestrator.js

@@ -224,6 +224,7 @@ function buildPrOptions(options, requiredQualityGates) {
     prBase: options.prBase || null,
     mergeQueue: options.mergeQueue || false,
     closeIssue: options.closeIssue || null,
+    gitRemote: options.gitRemote || null,
     autoMerge,
     ...(requiredQualityGates.length > 0 ? { requiredQualityGates } : {}),
     cwd: options.cwd || process.cwd(),
@@ -1266,6 +1267,8 @@ class Orchestrator {
         const { detectGitContext } = require('../lib/git-remote-utils');
         const gitContext = detectGitContext(options.cwd);
         cluster.gitPlatform = gitContext?.provider || null;
+        options.gitRemote = gitContext?.remote || options.gitRemote || null;
+        cluster.prOptions = buildPrOptions(options, requiredQualityGates);
 
         if (cluster.gitPlatform) {
           this._log(`[Orchestrator] Git platform detected: ${cluster.gitPlatform.toUpperCase()}`);
@@ -1796,18 +1799,30 @@ class Orchestrator {
       const workDir = options.cwd || process.cwd();
 
       isolationManager = new IsolationManager({});
-      // `prBase` is the PR target branch. Use that same local ref as the
-      // worktree base so repo-local integration commits are not skipped.
+      const { detectGitContext } = require('../lib/git-remote-utils');
+      const gitContext = detectGitContext(workDir);
+      if (gitContext?.remote) {
+        options.gitRemote = gitContext.remote;
+      }
+
+      // `prBase` is the PR target branch. Base isolated work on its refreshed
+      // remote-tracking ref so a stale local branch cannot change the plan.
       const worktreeOptions = {};
       if (options.prBase) {
-        worktreeOptions.baseRef = options.prBase;
-        this._log(`[Orchestrator] Using worktree base ref: ${options.prBase}`);
+        const remoteName = options.gitRemote || 'origin';
+        worktreeOptions.baseRef = `${remoteName}/${options.prBase}`;
+        if (remoteName !== 'origin') {
+          worktreeOptions.remoteName = remoteName;
+        }
+        worktreeOptions.requireFreshBase = true;
+        this._log(`[Orchestrator] Using worktree base ref: ${worktreeOptions.baseRef}`);
       }
       worktreeInfo = isolationManager.createWorktreeIsolation(clusterId, workDir, worktreeOptions);
 
       this._log(`[Orchestrator] Starting cluster in worktree isolation mode`);
       this._log(`[Orchestrator] Worktree: ${worktreeInfo.path}`);
       this._log(`[Orchestrator] Branch: ${worktreeInfo.branch}`);
+      this._log(`[Orchestrator] Worktree base commit: ${worktreeInfo.baseSha}`);
     }
 
     return { isolationManager, containerId, worktreeInfo, image: isolationImage };
@@ -1870,16 +1885,13 @@ class Orchestrator {
       closeIssue: options.closeIssue,
       requiredQualityGates: options.requiredQualityGates,
       autoMerge: resolveRunPlan(options).autoMerge,
+      gitRemote: gitContext?.remote || options.gitRemote,
+      issueNumber: inputData.number,
+      issueTitle: inputData.title,
+      includeIssueReference: !skipCloseIssue,
       cwd: options.cwd,
     });
 
-    // Template replacement for issue context
-    const issueRef = skipCloseIssue ? '' : `Closes #${inputData.number || 'unknown'}`;
-    gitPusherConfig.prompt = gitPusherConfig.prompt
-      .replace(/\{\{issue_number\}\}/g, inputData.number || 'unknown')
-      .replace(/\{\{issue_title\}\}/g, inputData.title || 'Implementation')
-      .replace(/Closes #\{\{issue_number\}\}/g, issueRef);
-
     config.agents.push(gitPusherConfig);
     this._log(
       `[Orchestrator] Injected ${platform}-git-pusher agent (issue: ${inputData.number || 'N/A'}, PR platform: ${platform.toUpperCase()})`
@@ -2649,31 +2661,68 @@ class Orchestrator {
   }
 
   _resolveFailureInfo(cluster, clusterId) {
-    if (cluster.failureInfo) {
-      return cluster.failureInfo.agentId ? cluster.failureInfo : null;
+    const persistedFailure = cluster.failureInfo?.agentId ? cluster.failureInfo : null;
+    if (persistedFailure) {
+      if (!this._hasDurableProgressAfterFailure(cluster, clusterId, persistedFailure)) {
+        return persistedFailure;
+      }
+      this._log(
+        `[Orchestrator] Ignoring recovered registry failure from ${persistedFailure.agentId}; durable task progress followed it`
+      );
     }
 
     const errors = cluster.messageBus.query({
       cluster_id: clusterId,
       topic: 'AGENT_ERROR',
-      limit: 10,
       order: 'desc',
     });
 
-    if (errors.length === 0) {
-      return null;
+    for (const error of errors) {
+      const failureInfo = {
+        agentId: error.sender,
+        taskId: error.content?.data?.taskId || null,
+        iteration: error.content?.data?.iteration || 0,
+        error: error.content?.data?.error || error.content?.text,
+        timestamp: error.timestamp,
+      };
+      if (this._hasDurableProgressAfterFailure(cluster, clusterId, failureInfo)) {
+        this._log(
+          `[Orchestrator] Ignoring recovered ledger failure from ${error.sender}; durable task progress followed it`
+        );
+        continue;
+      }
+
+      this._log(`[Orchestrator] Found failure from ledger: ${failureInfo.agentId}`);
+      return failureInfo;
     }
 
-    const firstError = errors[0];
-    const failureInfo = {
-      agentId: firstError.sender,
-      taskId: firstError.content?.data?.taskId || null,
-      iteration: firstError.content?.data?.iteration || 0,
-      error: firstError.content?.data?.error || firstError.content?.text,
-      timestamp: firstError.timestamp,
-    };
-    this._log(`[Orchestrator] Found failure from ledger: ${failureInfo.agentId}`);
-    return failureInfo;
+    return null;
+  }
+
+  _hasDurableProgressAfterFailure(cluster, clusterId, failureInfo) {
+    const failureIteration = failureInfo.iteration;
+    const failureTimestamp = failureInfo.timestamp;
+    return cluster.messageBus
+      .query({
+        cluster_id: clusterId,
+        topic: 'AGENT_LIFECYCLE',
+        sender: failureInfo.agentId,
+        since: failureTimestamp,
+      })
+      .some((message) => {
+        const event = message.content?.data?.event;
+        if (!['TASK_STARTED', 'TASK_COMPLETED'].includes(event)) {
+          return false;
+        }
+
+        const iteration = message.content?.data?.iteration;
+        return (
+          (Number.isFinite(failureTimestamp) && message.timestamp > failureTimestamp) ||
+          (Number.isInteger(failureIteration) &&
+            Number.isInteger(iteration) &&
+            iteration > failureIteration)
+        );
+      });
   }
 
   _requireFailedAgent(clusterId, cluster, failureInfo) {
@@ -3996,7 +4045,6 @@ Continue from where you left off. Review your previous output to understand what
         }
       }
 
-      // Generate platform-specific git-pusher agent from template
       const {
         generateGitPusherAgent,
         isPlatformSupported,
@@ -4008,18 +4056,19 @@ Continue from where you left off. Review your previous output to understand what
         );
       }
 
-      // Use persisted PR options from cluster state (or empty for repo settings fallback)
-      const gitPusherConfig = generateGitPusherAgent(platform, cluster.prOptions || {});
-
       // Get issue context from ledger
       const issueMsg = cluster.messageBus.ledger.findLast({ topic: 'ISSUE_OPENED' });
       const issueNumber = issueMsg?.content?.data?.number || 'unknown';
       const issueTitle = issueMsg?.content?.data?.title || 'Implementation';
 
-      // Inject issue context into prompt
-      gitPusherConfig.prompt = gitPusherConfig.prompt
-        .replace(/\{\{issue_number\}\}/g, issueNumber)
-        .replace(/\{\{issue_title\}\}/g, issueTitle);
+      // Generate the final prompt in one typed assembly pass. Issue values are
+      // resolved before the shell-quoted remote is inserted, so placeholder-like
+      // remote names cannot be rewritten by issue context.
+      const gitPusherConfig = generateGitPusherAgent(platform, {
+        ...(cluster.prOptions || {}),
+        issueNumber,
+        issueTitle,
+      });
 
       await this._opAddAgents(cluster, { agents: [gitPusherConfig] }, context);
       this._log(`    [--pr mode] Injected ${platform}-git-pusher agent`);

package/src/providers/index.js

@@ -129,6 +129,11 @@ class RuntimeProvider extends BaseProvider {
     return this._adapter.validateModelId(modelId);
   }
 
+  validateConfiguredModelId(modelId) {
+    const validator = this._adapter.validateConfiguredModelId || this._adapter.validateModelId;
+    return validator(modelId);
+  }
+
   isRetryableError(err) {
     return helper.classifyProviderError(this.name, err).retryable;
   }

package/src/task-run-model-args.js

@@ -0,0 +1,155 @@
+/**
+ * Append a resolved model selection to a nested `zeroshot task run` invocation.
+ *
+ * Direct requests use the public, catalog-strict `--model` channel.
+ * Provider-level selections carry only their level. The child must resolve the
+ * concrete model again from its effective provider settings.
+ *
+ * @param {string[]} args
+ * @param {Object|null|undefined} modelSpec
+ * @param {'direct'|'provider-level'} [modelSpecSource]
+ * @returns {string[]}
+ */
+function appendTaskRunModelArgs(args, modelSpec, modelSpecSource = 'direct') {
+  if (modelSpecSource === 'provider-level') {
+    if (!modelSpec?.level) {
+      throw new Error('Provider-level task model selections require a model level');
+    }
+    args.push('--model-level', modelSpec.level);
+  } else if (modelSpec?.model) {
+    args.push('--model', modelSpec.model);
+  }
+
+  if (modelSpec?.reasoningEffort) {
+    args.push('--reasoning-effort', modelSpec.reasoningEffort);
+  }
+
+  return args;
+}
+
+const ISOLATED_SETTINGS_FILE_ENV = 'ZEROSHOT_SETTINGS_FILE';
+const ISOLATED_SETTINGS_FILE_MARKER = 'ZEROSHOT_DOCKER_SETTINGS_FILE';
+const LEGACY_ISOLATED_PROVIDER_SETTINGS_ENV = 'ZEROSHOT_ISOLATED_PROVIDER_SETTINGS_JSON';
+const SETTINGS_BOOTSTRAP_SCRIPT = String.raw`
+const childProcess = require('node:child_process');
+const fs = require('node:fs');
+const os = require('node:os');
+const path = require('node:path');
+
+const snapshot = process.argv[1];
+const command = process.argv[2];
+const args = process.argv.slice(3);
+const directory = fs.mkdtempSync(path.join(os.tmpdir(), 'zeroshot-isolated-settings-'));
+const settingsFile = path.join(directory, 'settings.json');
+
+try {
+  fs.writeFileSync(settingsFile, snapshot, { encoding: 'utf8', flag: 'wx', mode: 0o600 });
+  const result = childProcess.spawnSync(command, args, {
+    stdio: 'inherit',
+    env: {
+      ...process.env,
+      ${ISOLATED_SETTINGS_FILE_ENV}: settingsFile,
+      ${ISOLATED_SETTINGS_FILE_MARKER}: '1',
+    },
+  });
+  if (result.error) throw result.error;
+  process.exitCode = result.status === null ? 1 : result.status;
+} finally {
+  fs.rmSync(directory, { recursive: true, force: true });
+}
+`.trim();
+
+/**
+ * Wrap an isolated task command with a Docker-only, temporary settings-file
+ * bootstrap. The snapshot is a closed projection containing only the selected
+ * OpenCode level and its model. It never contains arbitrary provider settings,
+ * credentials, or caller-owned keys.
+ *
+ * @param {string[]} command
+ * @param {{providerName: string, settings: Object, modelSpecSource: 'direct'|'provider-level', modelSpec: Object|null|undefined}} context
+ * @returns {string[]}
+ */
+function wrapTaskRunWithIsolatedSettings(command, context) {
+  const { providerName, settings, modelSpecSource, modelSpec } = context;
+  if (providerName !== 'opencode' || modelSpecSource !== 'provider-level') return command;
+  const snapshot = buildIsolatedSettingsSnapshot(settings, modelSpec);
+  if (snapshot === null) return command;
+  return ['node', '-e', SETTINGS_BOOTSTRAP_SCRIPT, snapshot, ...command];
+}
+
+function buildIsolatedSettingsSnapshot(settings, modelSpec) {
+  const level = modelSpec?.level;
+  if (!['level1', 'level2', 'level3'].includes(level)) {
+    throw permanentError(
+      'Provider-level isolated OpenCode selections require a valid model level.'
+    );
+  }
+
+  const providerSettings = ownRecordValue(settings, 'providerSettings', 'settings') ?? {};
+  const opencodeSettings = ownRecordValue(
+    providerSettings,
+    'opencode',
+    'settings.providerSettings'
+  );
+  const levelOverrides = ownRecordValue(
+    opencodeSettings,
+    'levelOverrides',
+    'settings.providerSettings.opencode'
+  );
+  const levelOverride = ownRecordValue(
+    levelOverrides,
+    level,
+    'settings.providerSettings.opencode.levelOverrides'
+  );
+  const configuredModel =
+    levelOverride && Object.prototype.hasOwnProperty.call(levelOverride, 'model')
+      ? levelOverride.model
+      : null;
+  if (configuredModel !== null && typeof configuredModel !== 'string') {
+    throw permanentError(`Configured isolated OpenCode ${level} model must be a string or null.`);
+  }
+  if (modelSpec?.model !== configuredModel) {
+    throw permanentError(
+      `Provider-level model "${modelSpec?.model}" does not match the effective isolated ${modelSpec?.level} model "${configuredModel}".`
+    );
+  }
+  if (configuredModel === null) return null;
+
+  return JSON.stringify({
+    providerSettings: {
+      opencode: {
+        levelOverrides: {
+          [level]: { model: configuredModel },
+        },
+      },
+    },
+  });
+}
+
+function ownRecordValue(record, key, field) {
+  if (record === null || record === undefined) return undefined;
+  if (typeof record !== 'object' || Array.isArray(record)) {
+    throw permanentError(`${field} must be an object.`);
+  }
+  if (!Object.prototype.hasOwnProperty.call(record, key)) return undefined;
+  const value = record[key];
+  if (value === null || value === undefined) return undefined;
+  if (typeof value !== 'object' || Array.isArray(value)) {
+    throw permanentError(`${field}.${key} must be an object.`);
+  }
+  return value;
+}
+
+function permanentError(message) {
+  const error = new Error(message);
+  error.permanent = true;
+  return error;
+}
+
+module.exports = {
+  ISOLATED_SETTINGS_FILE_ENV,
+  ISOLATED_SETTINGS_FILE_MARKER,
+  LEGACY_ISOLATED_PROVIDER_SETTINGS_ENV,
+  appendTaskRunModelArgs,
+  wrapTaskRunWithIsolatedSettings,
+};

package/task-lib/attachable-watcher.js

@@ -5,10 +5,8 @@
  * Runs detached from parent, provides Unix socket for attach clients.
  */
 
-import { appendFileSync, existsSync, mkdirSync, unlinkSync } from 'fs';
+import { appendFileSync, unlinkSync } from 'fs';
 import { unlink } from 'fs/promises';
-import { join } from 'path';
-import { homedir } from 'os';
 import { updateTask } from './store.js';
 import {
   detectProviderFatalError,
@@ -72,6 +70,7 @@ process.on('unhandledRejection', (reason) => {
 
 const require = createRequire(import.meta.url);
 const { AttachServer } = require('../src/attach');
+const { getTaskSocketPath } = require('../src/attach/socket-paths');
 const { normalizeProviderName } = require('../lib/provider-names');
 
 const taskId = taskIdArg;
@@ -88,12 +87,7 @@ const commandSpec = config.commandSpec || {
 commandSpecCleanup = commandSpec.cleanup || [];
 let server = null;
 
-const SOCKET_DIR = join(homedir(), '.zeroshot', 'sockets');
-const socketPath = join(SOCKET_DIR, `${taskId}.sock`);
-
-if (!existsSync(SOCKET_DIR)) {
-  mkdirSync(SOCKET_DIR, { recursive: true });
-}
+const socketPath = getTaskSocketPath(taskId);
 
 function log(msg) {
   appendFileSync(logFile, msg);

package/task-lib/commands/run.js

@@ -1,5 +1,5 @@
 import chalk from 'chalk';
-import { spawnTask } from '../runner.js';
+import { shouldUseAttachableWatcher, spawnTask } from '../runner.js';
 
 export async function runTask(prompt, options = {}) {
   if (!prompt || prompt.trim().length === 0) {
@@ -46,8 +46,23 @@ export async function runTask(prompt, options = {}) {
   console.log(chalk.dim(`  Log: ${task.logFile}`));
   console.log(chalk.dim(`  CWD: ${task.cwd}`));
 
+  const attachSupported = shouldUseAttachableWatcher(
+    {
+      jsonSchema: outputFormat === 'json' ? jsonSchema : null,
+    },
+    task.provider
+  );
+
   console.log(chalk.dim('\nCommands:'));
-  console.log(chalk.dim(`  zeroshot attach ${task.id}    # Attach to task (Ctrl+B d to detach)`));
+  if (attachSupported) {
+    console.log(chalk.dim(`  zeroshot attach ${task.id}    # Attach to task (Ctrl+B d to detach)`));
+  } else {
+    console.log(
+      chalk.dim(
+        `  Attach unavailable: ${task.provider} strict structured output uses a non-PTY watcher`
+      )
+    );
+  }
   console.log(chalk.dim(`  zeroshot logs ${task.id}      # View output`));
   console.log(chalk.dim(`  zeroshot logs -f ${task.id}   # Follow output`));
   console.log(chalk.dim(`  zeroshot status ${task.id}    # Check status`));

package/task-lib/runner.js

@@ -7,6 +7,11 @@ import { createRequire } from 'module';
 
 const require = createRequire(import.meta.url);
 const { prepareSingleAgentProviderCommand } = require('./provider-helper-runtime.js');
+const {
+  ISOLATED_SETTINGS_FILE_ENV,
+  ISOLATED_SETTINGS_FILE_MARKER,
+  LEGACY_ISOLATED_PROVIDER_SETTINGS_ENV,
+} = require('../src/task-run-model-args.js');
 export {
   isOwnedProcessTreeRunning,
   isProcessRunning,
@@ -25,10 +30,10 @@ export function spawnTask(prompt, options = {}) {
 
   const outputFormat = resolveOutputFormat(options);
   const jsonSchema = resolveJsonSchema(options, outputFormat);
-  const prepared = prepareSingleAgentProviderCommand({
-    provider: options.provider || null,
-    context: prompt,
-    options: buildProviderOptions(options, outputFormat, jsonSchema, cwd),
+  const prepared = prepareTaskProviderCommandFromResolved(prompt, options, {
+    outputFormat,
+    jsonSchema,
+    cwd,
   });
   const providerName = prepared.adapter.id;
   const modelSpec = prepared.options.modelSpec;
@@ -53,7 +58,13 @@ export function spawnTask(prompt, options = {}) {
     providerName,
     commandSpec
   );
-  const watcherScript = resolveWatcherScript(options);
+  const watcherScript = resolveWatcherScript(
+    {
+      attachable: options.attachable,
+      jsonSchema,
+    },
+    providerName
+  );
   spawnWatcher({
     watcherScript,
     id,
@@ -66,6 +77,24 @@ export function spawnTask(prompt, options = {}) {
   return task;
 }
 
+export function prepareTaskProviderCommand(prompt, options = {}) {
+  const outputFormat = resolveOutputFormat(options);
+  return prepareTaskProviderCommandFromResolved(prompt, options, {
+    outputFormat,
+    jsonSchema: resolveJsonSchema(options, outputFormat),
+    cwd: options.cwd || process.cwd(),
+  });
+}
+
+function prepareTaskProviderCommandFromResolved(prompt, options, runtime) {
+  const modelSelection = resolveRequestedModelSelection(options);
+  return prepareSingleAgentProviderCommand({
+    provider: options.provider || null,
+    context: prompt,
+    options: buildProviderOptions(options, runtime, modelSelection),
+  });
+}
+
 function resolveOutputFormat(options) {
   return options.outputFormat || 'stream-json';
 }
@@ -79,13 +108,13 @@ function resolveJsonSchema(options, outputFormat) {
   return jsonSchema;
 }
 
-function buildProviderOptions(options, outputFormat, jsonSchema, cwd) {
+function buildProviderOptions(options, runtime, modelSelection) {
   return {
-    outputFormat,
-    jsonSchema,
-    cwd,
+    outputFormat: runtime.outputFormat,
+    jsonSchema: runtime.jsonSchema,
+    cwd: runtime.cwd,
     autoApprove: true,
-    ...modelSpecOption(options),
+    ...(modelSelection === undefined ? {} : { modelSpec: modelSelection.modelSpec }),
     ...mcpConfigOption(options),
     ...(options.resume ? { resumeSessionId: options.resume } : {}),
     ...(options.continue ? { continueSession: true } : {}),
@@ -98,27 +127,32 @@ function mcpConfigOption(options) {
   return { mcpConfig: entries };
 }
 
-function modelSpecOption(options) {
-  const modelSpec = resolveRequestedModelSpec(options);
-  return modelSpec === undefined ? {} : { modelSpec };
-}
+function resolveRequestedModelSelection(options) {
+  if (Object.prototype.hasOwnProperty.call(options, 'configuredModel')) {
+    throw new Error(
+      '--configured-model is not supported; configure providerSettings levelOverrides instead'
+    );
+  }
 
-function resolveRequestedModelSpec(options) {
   if (options.model) {
-    return {
-      model: options.model,
-      ...(options.reasoningEffort ? { reasoningEffort: options.reasoningEffort } : {}),
-    };
+    return directModelSelection(options);
   }
 
-  if (options.reasoningEffort) {
-    return {
-      ...(options.modelLevel ? { level: options.modelLevel } : {}),
-      reasoningEffort: options.reasoningEffort,
-    };
-  }
-  if (options.modelLevel) return { level: options.modelLevel };
-  return undefined;
+  return providerLevelSelection(options);
+}
+
+function directModelSelection(options) {
+  const modelSpec = { model: options.model };
+  if (options.reasoningEffort) modelSpec.reasoningEffort = options.reasoningEffort;
+  return { modelSpec };
+}
+
+function providerLevelSelection(options) {
+  if (!options.reasoningEffort && !options.modelLevel) return undefined;
+  const modelSpec = {};
+  if (options.modelLevel) modelSpec.level = options.modelLevel;
+  if (options.reasoningEffort) modelSpec.reasoningEffort = options.reasoningEffort;
+  return { modelSpec };
 }
 
 function buildTaskRecord({ id, prompt, cwd, options, logFile, providerName, modelSpec }) {
@@ -165,12 +199,25 @@ function buildWatcherCommandSpec(commandSpec) {
   return watcherCommandSpec;
 }
 
-function resolveWatcherScript(options) {
-  const useAttachable = options.attachable !== false && !options.jsonSchema;
+export function shouldUseAttachableWatcher(options, providerName) {
+  if (options.attachable === false) {
+    return false;
+  }
+
+  // Claude strict structured output still needs the non-PTY watcher. Claude
+  // can treat PTY notifications as streaming commands and reject the run.
+  // Other providers, including Codex, support their structured-output mode in
+  // the attachable PTY watcher and must not lose the advertised attach socket.
+  return !(providerName === 'claude' && options.jsonSchema);
+}
+
+function resolveWatcherScript(options, providerName) {
+  const useAttachable = shouldUseAttachableWatcher(options, providerName);
   return useAttachable ? join(__dirname, 'attachable-watcher.js') : join(__dirname, 'watcher.js');
 }
 
 function spawnWatcher({ watcherScript, id, cwd, logFile, finalArgs, watcherConfig }) {
+  const watcherEnv = buildWatcherEnv();
   const watcher = fork(
     watcherScript,
     [id, cwd, logFile, JSON.stringify(finalArgs), JSON.stringify(watcherConfig)],
@@ -178,9 +225,20 @@ function spawnWatcher({ watcherScript, id, cwd, logFile, finalArgs, watcherConfi
       detached: true,
       stdio: 'ignore',
       windowsHide: true,
+      env: watcherEnv,
     }
   );
 
   watcher.unref();
   watcher.disconnect(); // Close IPC channel so parent can exit
 }
+
+export function buildWatcherEnv(sourceEnv = process.env) {
+  const watcherEnv = { ...sourceEnv };
+  delete watcherEnv[LEGACY_ISOLATED_PROVIDER_SETTINGS_ENV];
+  if (watcherEnv[ISOLATED_SETTINGS_FILE_MARKER] === '1') {
+    delete watcherEnv[ISOLATED_SETTINGS_FILE_ENV];
+    delete watcherEnv[ISOLATED_SETTINGS_FILE_MARKER];
+  }
+  return watcherEnv;
+}