@the-open-engine/zeroshot 6.38.0 → 6.39.0

package/lib/setup-undo.d.ts

@@ -0,0 +1,44 @@
+/**
+ * `zeroshot setup undo` — reverts writes made by `zeroshot setup apply` using
+ * the journal recorded at apply time (lib/setup-journal.js).
+ *
+ * Three-way conflict rule per journaled write, comparing `current` against
+ * `appliedValue`:
+ *   - current === appliedValue      -> restore priorValue (delete if null)
+ *   - current === priorValue        -> already-restored (no-op)
+ *   - otherwise (changed elsewhere) -> skipped-modified, never clobbered
+ */
+type SettingsRecord = Record<string, unknown>;
+type UndoStatus = 'already-restored' | 'skipped-modified' | 'deleted' | 'restored';
+interface JournalEntry {
+    readonly appliedAt: string;
+    readonly appliedValue: unknown;
+    readonly path: string;
+    readonly priorValue: unknown;
+    readonly repoRoot: string | null;
+    readonly scope: string;
+    readonly [key: string]: unknown;
+}
+interface UndoResult extends JournalEntry {
+    current?: unknown;
+    status: UndoStatus;
+    wouldRestore?: unknown;
+}
+interface UndoDependencies {
+    mutateSettings<T>(mutator: (settings: SettingsRecord) => T): T;
+    readRepoSettings(repoRoot: string | null): {
+        settings: SettingsRecord | null;
+    };
+    writeRepoSettings(repoRoot: string | null, settings: SettingsRecord): unknown;
+}
+interface UndoParams {
+    deps?: Partial<UndoDependencies>;
+}
+/**
+ * Undo every journaled write, per the three-way conflict rule.
+ */
+declare function undo({ deps }?: UndoParams): Array<UndoResult | undefined>;
+declare const _default: {
+    undo: typeof undo;
+};
+export = _default;

package/lib/setup-undo.js

@@ -1,3 +1,4 @@
+"use strict";
 /**
  * `zeroshot setup undo` — reverts writes made by `zeroshot setup apply` using
  * the journal recorded at apply time (lib/setup-journal.js).
@@ -8,90 +9,76 @@
  *   - current === priorValue        -> already-restored (no-op)
  *   - otherwise (changed elsewhere) -> skipped-modified, never clobbered
  */
-
-const {
-  loadJournal,
-  getNestedValue,
-  setNestedValue,
-  deleteNestedKey,
-  deepEqual,
-} = require('./setup-journal');
-
+const setupJournal = require("./setup-journal");
+const { loadJournal, getNestedValue, setNestedValue, deleteNestedKey, deepEqual, } = setupJournal;
 function defaultUndoDeps() {
-  const { mutateSettings } = require('./settings');
-  const { readRepoSettings, writeRepoSettings } = require('./repo-settings');
-
-  return { mutateSettings, readRepoSettings, writeRepoSettings };
+    // These CommonJS paths intentionally resolve beside the emitted module in lib/.
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+    const { mutateSettings } = require('./settings');
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+    const { readRepoSettings, writeRepoSettings, } = require('./repo-settings');
+    return { mutateSettings, readRepoSettings, writeRepoSettings };
 }
-
 /**
  * Undo every journaled write, per the three-way conflict rule.
- *
- * @param {Object} [params]
- * @param {Object} [params.deps] - Injected dependencies (for testing).
- * @returns {Array<{scope: string, path: string, repoRoot: string|null, status: string, current?: *, wouldRestore?: *}>}
  */
 function undo({ deps = {} } = {}) {
-  const resolvedDeps = { ...defaultUndoDeps(), ...deps };
-  const journal = loadJournal();
-
-  const repoSettingsCache = new Map();
-  const dirtyRepoRoots = new Set();
-
-  function repoSettingsFor(repoRoot) {
-    if (!repoSettingsCache.has(repoRoot)) {
-      const { settings } = resolvedDeps.readRepoSettings(repoRoot);
-      repoSettingsCache.set(repoRoot, settings || {});
-    }
-    return repoSettingsCache.get(repoRoot);
-  }
-
-  function restoreEntry(entry, settingsObj) {
-    const current = getNestedValue(settingsObj, entry.path) ?? null;
-    if (deepEqual(current, entry.priorValue)) {
-      return { ...entry, status: 'already-restored' };
+    const resolvedDeps = { ...defaultUndoDeps(), ...deps };
+    const journal = loadJournal();
+    const repoSettingsCache = new Map();
+    const dirtyRepoRoots = new Set();
+    function repoSettingsFor(repoRoot) {
+        const cachedSettings = repoSettingsCache.get(repoRoot);
+        if (cachedSettings) {
+            return cachedSettings;
+        }
+        const { settings } = resolvedDeps.readRepoSettings(repoRoot);
+        const resolvedSettings = settings || {};
+        repoSettingsCache.set(repoRoot, resolvedSettings);
+        return resolvedSettings;
     }
-    if (!deepEqual(current, entry.appliedValue)) {
-      return { ...entry, status: 'skipped-modified', current, wouldRestore: entry.priorValue };
+    function restoreEntry(entry, settingsObj) {
+        const current = getNestedValue(settingsObj, entry.path) ?? null;
+        if (deepEqual(current, entry.priorValue)) {
+            return { ...entry, status: 'already-restored' };
+        }
+        if (!deepEqual(current, entry.appliedValue)) {
+            return { ...entry, status: 'skipped-modified', current, wouldRestore: entry.priorValue };
+        }
+        if (entry.priorValue === null) {
+            deleteNestedKey(settingsObj, entry.path);
+        }
+        else {
+            setNestedValue(settingsObj, entry.path, entry.priorValue);
+        }
+        return { ...entry, status: entry.priorValue === null ? 'deleted' : 'restored' };
     }
-    if (entry.priorValue === null) {
-      deleteNestedKey(settingsObj, entry.path);
-    } else {
-      setNestedValue(settingsObj, entry.path, entry.priorValue);
+    const resultsByIndex = new Map();
+    const globalEntries = journal.entries
+        .map((entry, index) => ({ entry, index }))
+        .filter(({ entry }) => entry.scope === 'global');
+    if (globalEntries.length > 0) {
+        const globalResults = resolvedDeps.mutateSettings((freshGlobalSettings) => {
+            return globalEntries.map(({ entry }) => restoreEntry(entry, freshGlobalSettings));
+        });
+        globalEntries.forEach(({ index }, resultIndex) => {
+            resultsByIndex.set(index, globalResults[resultIndex]);
+        });
     }
-    return { ...entry, status: entry.priorValue === null ? 'deleted' : 'restored' };
-  }
-
-  const resultsByIndex = new Map();
-  const globalEntries = journal.entries
-    .map((entry, index) => ({ entry, index }))
-    .filter(({ entry }) => entry.scope === 'global');
-
-  if (globalEntries.length > 0) {
-    const globalResults = resolvedDeps.mutateSettings((freshGlobalSettings) =>
-      globalEntries.map(({ entry }) => restoreEntry(entry, freshGlobalSettings))
-    );
-    globalEntries.forEach(({ index }, resultIndex) => {
-      resultsByIndex.set(index, globalResults[resultIndex]);
+    journal.entries.forEach((entry, index) => {
+        if (entry.scope !== 'repo')
+            return;
+        const result = restoreEntry(entry, repoSettingsFor(entry.repoRoot));
+        resultsByIndex.set(index, result);
+        if (result.status === 'restored' || result.status === 'deleted') {
+            dirtyRepoRoots.add(entry.repoRoot);
+        }
     });
-  }
-
-  journal.entries.forEach((entry, index) => {
-    if (entry.scope !== 'repo') return;
-    const result = restoreEntry(entry, repoSettingsFor(entry.repoRoot));
-    resultsByIndex.set(index, result);
-    if (result.status === 'restored' || result.status === 'deleted') {
-      dirtyRepoRoots.add(entry.repoRoot);
+    for (const repoRoot of dirtyRepoRoots) {
+        resolvedDeps.writeRepoSettings(repoRoot, repoSettingsFor(repoRoot));
     }
-  });
-
-  for (const repoRoot of dirtyRepoRoots) {
-    resolvedDeps.writeRepoSettings(repoRoot, repoSettingsFor(repoRoot));
-  }
-
-  // Journal entries are left in place (not cleared) so a re-run reports
-  // 'already-restored' instead of finding nothing to undo.
-  return journal.entries.map((_, index) => resultsByIndex.get(index));
+    // Journal entries are left in place (not cleared) so a re-run reports
+    // 'already-restored' instead of finding nothing to undo.
+    return journal.entries.map((_, index) => resultsByIndex.get(index));
 }
-
 module.exports = { undo };

package/lib/start-cluster-config.d.ts

@@ -0,0 +1,26 @@
+interface ClusterConfig extends Record<string, unknown> {
+    defaultLevel?: unknown;
+    defaultProvider?: string;
+    forceLevel?: unknown;
+    forceProvider?: string;
+    params?: Record<string, unknown>;
+}
+interface ProviderSettings {
+    defaultLevel?: unknown;
+}
+interface Settings {
+    defaultProvider?: string;
+    providerSettings?: Record<string, ProviderSettings>;
+}
+interface OrchestratorFacade {
+    loadConfig(configPath: string): ClusterConfig;
+}
+declare function resolveConfigPath(configName: string): string;
+declare function prepareClusterConfig(config: ClusterConfig, settings?: Settings, providerOverride?: string | null): ClusterConfig;
+declare function loadClusterConfig(orchestrator: OrchestratorFacade, configPath: string, settings?: Settings, providerOverride?: string | null): ClusterConfig;
+declare const _default: {
+    resolveConfigPath: typeof resolveConfigPath;
+    prepareClusterConfig: typeof prepareClusterConfig;
+    loadClusterConfig: typeof loadClusterConfig;
+};
+export = _default;

package/lib/start-cluster-config.js

@@ -0,0 +1,56 @@
+"use strict";
+const path = require("path");
+// eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+const chalk = require('chalk');
+// eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+const providerNames = require('./provider-names');
+// eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+const providers = require('../src/providers');
+// eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+const TemplateResolver = require('../src/template-resolver');
+const { normalizeProviderName, getDefaultProviderId } = providerNames;
+const { getProvider } = providers;
+const PACKAGE_ROOT = path.resolve(__dirname, '..');
+function resolveConfigPath(configName) {
+    if (path.isAbsolute(configName) || configName.startsWith('./') || configName.startsWith('../')) {
+        return path.resolve(process.cwd(), configName);
+    }
+    if (configName.endsWith('.json')) {
+        return path.join(PACKAGE_ROOT, 'cluster-templates', configName);
+    }
+    return path.join(PACKAGE_ROOT, 'cluster-templates', `${configName}.json`);
+}
+function ensureConfigProviderDefaults(config, settings) {
+    if (!config.defaultProvider) {
+        config.defaultProvider = settings.defaultProvider || getDefaultProviderId();
+    }
+    config.defaultProvider = normalizeProviderName(config.defaultProvider) || getDefaultProviderId();
+}
+function applyProviderOverrideToConfig(config, providerOverride, settings) {
+    const provider = getProvider(providerOverride);
+    const providerSettings = settings.providerSettings?.[providerOverride] || {};
+    config.forceProvider = providerOverride;
+    config.defaultProvider = providerOverride;
+    config.forceLevel = providerSettings.defaultLevel || provider.getDefaultLevel();
+    config.defaultLevel = config.forceLevel;
+    console.log(chalk.dim(`Provider override: ${providerOverride} (all agents)`));
+}
+function resolveParameterizedConfigFile(config) {
+    if (!config?.params || Object.keys(config.params).length === 0) {
+        return config;
+    }
+    const resolver = new TemplateResolver(path.join(PACKAGE_ROOT, 'cluster-templates'));
+    return resolver.resolveTemplate(config, {});
+}
+function prepareClusterConfig(config, settings = {}, providerOverride) {
+    const prepared = resolveParameterizedConfigFile(config);
+    ensureConfigProviderDefaults(prepared, settings);
+    if (providerOverride) {
+        applyProviderOverrideToConfig(prepared, providerOverride, settings);
+    }
+    return prepared;
+}
+function loadClusterConfig(orchestrator, configPath, settings = {}, providerOverride) {
+    return prepareClusterConfig(orchestrator.loadConfig(configPath), settings, providerOverride);
+}
+module.exports = { resolveConfigPath, prepareClusterConfig, loadClusterConfig };

package/lib/start-cluster-environment.d.ts

@@ -0,0 +1,40 @@
+type CloseIssueMode = 'auto' | 'always' | 'never';
+interface RunOptions extends Record<string, unknown> {
+    closeIssue?: unknown;
+    dockerImage?: unknown;
+    isolation?: unknown;
+    mergeQueue?: unknown;
+    mount?: readonly string[] | null;
+    noIsolation?: unknown;
+    prBase?: unknown;
+}
+interface MountSpec {
+    host: string;
+    container: string;
+    readonly: boolean;
+}
+declare function firstTruthy<T>(...values: T[]): T | undefined;
+declare function anyTruthy(...values: unknown[]): boolean;
+declare function optionalValue<T>(value: T): T | undefined;
+declare function detectGitRepoRoot(): string;
+declare function resolveTargetCwd(): string | undefined;
+declare function resolveEnvBool(value: unknown): boolean | undefined;
+declare function mergeRunOptions(options: RunOptions): RunOptions;
+declare function resolveMergeQueue(options: RunOptions): boolean | undefined;
+declare function resolvePrBase(options: RunOptions): string | undefined;
+declare function resolveCloseIssue(options: RunOptions): CloseIssueMode | undefined;
+declare function resolveMounts(options: RunOptions): MountSpec[] | undefined;
+declare const _default: {
+    firstTruthy: typeof firstTruthy;
+    anyTruthy: typeof anyTruthy;
+    optionalValue: typeof optionalValue;
+    detectGitRepoRoot: typeof detectGitRepoRoot;
+    resolveTargetCwd: typeof resolveTargetCwd;
+    resolveEnvBool: typeof resolveEnvBool;
+    mergeRunOptions: typeof mergeRunOptions;
+    resolveMergeQueue: typeof resolveMergeQueue;
+    resolvePrBase: typeof resolvePrBase;
+    resolveCloseIssue: typeof resolveCloseIssue;
+    resolveMounts: typeof resolveMounts;
+};
+export = _default;

package/lib/start-cluster-environment.js

@@ -0,0 +1,134 @@
+"use strict";
+const child_process_1 = require("child_process");
+function firstTruthy(...values) {
+    return values.find(Boolean);
+}
+function anyTruthy(...values) {
+    return values.some(Boolean);
+}
+function optionalValue(value) {
+    return value || undefined;
+}
+function detectGitRepoRoot() {
+    try {
+        const result = (0, child_process_1.spawnSync)('git', ['rev-parse', '--show-toplevel'], {
+            encoding: 'utf8',
+            stdio: ['pipe', 'pipe', 'pipe'],
+        });
+        if (result.status !== 0) {
+            return process.cwd();
+        }
+        return result.stdout.trim();
+    }
+    catch {
+        return process.cwd();
+    }
+}
+function resolveTargetCwd() {
+    return firstTruthy(process.env.ZEROSHOT_CWD, detectGitRepoRoot());
+}
+function resolveOptionalString(value) {
+    if (typeof value !== 'string')
+        return undefined;
+    const trimmed = value.trim();
+    return trimmed.length > 0 ? trimmed : undefined;
+}
+function resolveEnvBool(value) {
+    if (typeof value !== 'string')
+        return undefined;
+    const trimmed = value.trim().toLowerCase();
+    if (trimmed === '1' || trimmed === 'true' || trimmed === 'yes')
+        return true;
+    if (trimmed === '0' || trimmed === 'false' || trimmed === 'no')
+        return false;
+    return undefined;
+}
+function resolveCloseIssueMode(value) {
+    const trimmed = resolveOptionalString(value);
+    if (!trimmed)
+        return undefined;
+    const normalized = trimmed.toLowerCase();
+    if (normalized === 'auto' || normalized === 'always' || normalized === 'never') {
+        return normalized;
+    }
+    return undefined;
+}
+function isRunOptions(value) {
+    return Boolean(value) && typeof value === 'object';
+}
+function parseRunOptionsEnv() {
+    const raw = resolveOptionalString(process.env.ZEROSHOT_RUN_OPTIONS);
+    if (!raw)
+        return null;
+    try {
+        const parsed = JSON.parse(raw);
+        if (!isRunOptions(parsed)) {
+            return null;
+        }
+        return parsed;
+    }
+    catch {
+        return null;
+    }
+}
+function parseMountSpecs(specs) {
+    return specs.map((spec) => {
+        const parts = spec.split(':');
+        if (parts.length < 2) {
+            throw new Error(`Invalid mount spec: "${spec}". Format: host:container[:ro]`);
+        }
+        const [host, container] = parts;
+        if (host === undefined || container === undefined) {
+            throw new Error(`Invalid mount spec: "${spec}". Format: host:container[:ro]`);
+        }
+        const readonly = parts[2] === 'ro';
+        return { host, container, readonly };
+    });
+}
+const RUN_MODE_KEYS = ['docker', 'worktree', 'pr', 'ship', 'noIsolation', 'isolation'];
+function hasExplicitRunMode(options) {
+    return RUN_MODE_KEYS.some((key) => options[key] === true || (key === 'isolation' && options[key] === false));
+}
+function mergeRunOptions(options) {
+    const envRunOptions = parseRunOptionsEnv();
+    if (!envRunOptions)
+        return options;
+    if (!hasExplicitRunMode(options))
+        return { ...envRunOptions, ...options };
+    const withoutEnvMode = { ...envRunOptions };
+    for (const key of RUN_MODE_KEYS)
+        delete withoutEnvMode[key];
+    return { ...withoutEnvMode, ...options };
+}
+function resolveMergeQueue(options) {
+    if (typeof options.mergeQueue === 'boolean') {
+        return options.mergeQueue;
+    }
+    return resolveEnvBool(process.env.ZEROSHOT_MERGE_QUEUE);
+}
+function resolvePrBase(options) {
+    return (resolveOptionalString(options.prBase) ||
+        resolveOptionalString(process.env.ZEROSHOT_PR_BASE) ||
+        undefined);
+}
+function resolveCloseIssue(options) {
+    return (resolveCloseIssueMode(options.closeIssue) ||
+        resolveCloseIssueMode(process.env.ZEROSHOT_CLOSE_ISSUE) ||
+        undefined);
+}
+function resolveMounts(options) {
+    return options.mount ? parseMountSpecs(options.mount) : undefined;
+}
+module.exports = {
+    firstTruthy,
+    anyTruthy,
+    optionalValue,
+    detectGitRepoRoot,
+    resolveTargetCwd,
+    resolveEnvBool,
+    mergeRunOptions,
+    resolveMergeQueue,
+    resolvePrBase,
+    resolveCloseIssue,
+    resolveMounts,
+};

package/lib/start-cluster-run-options.d.ts

@@ -0,0 +1,53 @@
+type RunIsolation = 'none' | 'worktree' | 'docker';
+type RunDelivery = 'none' | 'pr' | 'ship';
+interface RunPlan {
+    isolation: RunIsolation;
+    delivery: RunDelivery;
+    autoMerge: boolean;
+}
+interface Settings extends Record<string, unknown> {
+    defaultIsolation?: string;
+    defaultDelivery?: string;
+}
+interface RunOptions extends Record<string, unknown> {
+    autoMerge?: unknown;
+    autoPush?: unknown;
+    closeIssue?: unknown;
+    containerHome?: unknown;
+    cwd?: unknown;
+    docker?: unknown;
+    dockerImage?: unknown;
+    isolation?: unknown;
+    mergeQueue?: unknown;
+    mount?: readonly string[] | null;
+    mounts?: unknown;
+    noIsolation?: unknown;
+    noMounts?: unknown;
+    pr?: unknown;
+    prBase?: unknown;
+    preparedWorktree?: unknown;
+    requiredQualityGates?: unknown;
+    ship?: unknown;
+    worktree?: unknown;
+}
+interface BuildStartOptionsArgs {
+    clusterId?: unknown;
+    options?: RunOptions;
+    settings?: Settings;
+    providerOverride?: unknown;
+    modelOverride?: unknown;
+    forceProvider?: unknown;
+}
+interface BuildTrustedStartOptionsArgs extends BuildStartOptionsArgs {
+    plan?: RunPlan | null;
+}
+declare function resolveEffectiveRunPlan(options?: RunOptions, settings?: Settings): Readonly<RunPlan>;
+declare function buildStartOptions({ clusterId, options, settings, providerOverride, modelOverride, forceProvider, }: BuildStartOptionsArgs): Readonly<Record<string, unknown>>;
+declare function buildTrustedStartOptions({ clusterId, plan, options, settings, providerOverride, modelOverride, forceProvider, }: BuildTrustedStartOptionsArgs): Readonly<Record<string, unknown>>;
+declare const _default: {
+    buildStartOptions: typeof buildStartOptions;
+    buildTrustedStartOptions: typeof buildTrustedStartOptions;
+    resolveEffectiveRunPlan: typeof resolveEffectiveRunPlan;
+    detectGitRepoRoot: () => string;
+};
+export = _default;

package/lib/start-cluster-run-options.js

@@ -0,0 +1,147 @@
+"use strict";
+// eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+const runPlan = require('./run-plan');
+// eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+const runMode = require('./run-mode');
+// eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+const environmentHelpers = require('./start-cluster-environment');
+const { resolveRunPlan } = runPlan;
+const { runModeFromPlan } = runMode;
+const { firstTruthy, anyTruthy, optionalValue, detectGitRepoRoot, resolveTargetCwd, resolveEnvBool, mergeRunOptions, resolveMergeQueue, resolvePrBase, resolveCloseIssue, resolveMounts, } = environmentHelpers;
+function isRunIsolation(value) {
+    return value === 'none' || value === 'worktree' || value === 'docker';
+}
+function isRunDelivery(value) {
+    return value === 'none' || value === 'pr' || value === 'ship';
+}
+function validateSavedRunModes(settings) {
+    const isolation = settings.defaultIsolation || 'none';
+    const delivery = settings.defaultDelivery || 'none';
+    if (!isRunIsolation(isolation)) {
+        throw new Error(`Invalid saved isolation mode: ${isolation}`);
+    }
+    if (!isRunDelivery(delivery)) {
+        throw new Error(`Invalid saved delivery mode: ${delivery}`);
+    }
+    return { isolation, delivery };
+}
+function resolveEffectiveIsolation(options, savedIsolation) {
+    if (options.noIsolation === true || options.isolation === false)
+        return 'none';
+    if (options.docker === true)
+        return 'docker';
+    if (options.worktree === true || options.pr === true || options.ship === true)
+        return 'worktree';
+    if (resolveEnvBool(process.env.ZEROSHOT_DOCKER) === true)
+        return 'docker';
+    if (resolveEnvBool(process.env.ZEROSHOT_WORKTREE) === true)
+        return 'worktree';
+    return savedIsolation;
+}
+function resolveEffectiveDelivery(options, savedDelivery) {
+    if (options.ship === true || options.autoMerge === true)
+        return 'ship';
+    if (options.pr === true || resolveEnvBool(process.env.ZEROSHOT_PR) === true)
+        return 'pr';
+    return savedDelivery;
+}
+function resolveEffectiveRunPlan(options = {}, settings = {}) {
+    const mergedOptions = mergeRunOptions(options);
+    const noIsolation = mergedOptions.noIsolation === true || mergedOptions.isolation === false;
+    const conflicts = ['docker', 'worktree', 'pr', 'ship'].filter((key) => mergedOptions[key] === true);
+    if (noIsolation && conflicts.length > 0) {
+        throw new Error(`--no-isolation conflicts with --${conflicts.join(', --')}`);
+    }
+    const saved = validateSavedRunModes(settings);
+    let isolation = resolveEffectiveIsolation(mergedOptions, saved.isolation);
+    const delivery = resolveEffectiveDelivery(mergedOptions, saved.delivery);
+    if (delivery !== 'none' && isolation === 'none') {
+        if (noIsolation) {
+            throw new Error(`--no-isolation conflicts with saved delivery mode "${delivery}"`);
+        }
+        isolation = 'worktree';
+    }
+    return resolveRunPlan({
+        docker: isolation === 'docker',
+        worktree: isolation === 'worktree',
+        pr: delivery === 'pr',
+        ship: delivery === 'ship',
+    });
+}
+function buildStartOptionsFromPlan({ clusterId, plan, options, settings, providerOverride, modelOverride, forceProvider, preparedWorktree, environment, }) {
+    const targetCwd = environment ? resolveTargetCwd() : options.cwd;
+    return Object.freeze({
+        clusterId,
+        cwd: targetCwd,
+        isolation: plan.isolation === 'docker',
+        isolationImage: environment
+            ? firstTruthy(options.dockerImage, process.env.ZEROSHOT_DOCKER_IMAGE)
+            : optionalValue(options.dockerImage),
+        worktree: plan.isolation === 'worktree',
+        preparedWorktree: preparedWorktree || undefined,
+        autoPr: plan.delivery !== 'none',
+        autoMerge: plan.autoMerge,
+        autoPush: environment ? process.env.ZEROSHOT_PUSH === '1' : options.autoPush === true,
+        modelOverride: optionalValue(modelOverride),
+        providerOverride: optionalValue(providerOverride),
+        noMounts: anyTruthy(options.mounts === false, options.noMounts === true),
+        mounts: resolveMounts(options),
+        containerHome: optionalValue(options.containerHome),
+        forceProvider: optionalValue(forceProvider),
+        prBase: environment ? resolvePrBase(options) : optionalValue(options.prBase),
+        mergeQueue: environment ? resolveMergeQueue(options) : optionalValue(options.mergeQueue),
+        closeIssue: environment ? resolveCloseIssue(options) : optionalValue(options.closeIssue),
+        ship: plan.delivery === 'ship',
+        runMode: runModeFromPlan(plan),
+        requiredQualityGates: options.requiredQualityGates,
+        settings,
+    });
+}
+function buildStartOptions({ clusterId, options = {}, settings = {}, providerOverride, modelOverride, forceProvider, }) {
+    const mergedOptions = mergeRunOptions(options);
+    const plan = resolveEffectiveRunPlan(options, settings);
+    return buildStartOptionsFromPlan({
+        clusterId,
+        plan,
+        options: mergedOptions,
+        settings,
+        providerOverride,
+        modelOverride,
+        forceProvider,
+        environment: true,
+    });
+}
+function buildTrustedStartOptions({ clusterId, plan, options = {}, settings = {}, providerOverride, modelOverride, forceProvider, }) {
+    if (!plan || !Object.isFrozen(plan)) {
+        throw new Error('Trusted start requires a frozen canonical run plan');
+    }
+    const canonical = resolveRunPlan({
+        docker: plan.isolation === 'docker',
+        worktree: plan.isolation === 'worktree',
+        pr: plan.delivery === 'pr',
+        ship: plan.delivery === 'ship',
+    });
+    if (canonical.isolation !== plan.isolation ||
+        canonical.delivery !== plan.delivery ||
+        canonical.autoMerge !== plan.autoMerge) {
+        throw new Error('Trusted start plan is not canonical');
+    }
+    if (canonical.isolation === 'none') {
+        throw new Error('Trusted worker start requires worktree or docker isolation');
+    }
+    if (options.preparedWorktree && canonical.isolation !== 'worktree') {
+        throw new Error('Prepared worktree requires canonical worktree isolation');
+    }
+    return buildStartOptionsFromPlan({
+        clusterId,
+        plan: canonical,
+        options,
+        settings,
+        providerOverride,
+        modelOverride,
+        forceProvider,
+        preparedWorktree: options.preparedWorktree,
+        environment: false,
+    });
+}
+module.exports = { buildStartOptions, buildTrustedStartOptions, resolveEffectiveRunPlan, detectGitRepoRoot };