@loucompanion/forge-bridge 0.1.3-dev.ba7d36726eda → 0.1.3-dev.bca7d0ccee53

package/dist/runtime/host-runtime-promotion.js

@@ -19,6 +19,32 @@ export class HostParallelPromotionStore {
             throw error;
         }
     }
+    async list() {
+        const root = path.join(this.stateRoot, "runtime-promotion", "host");
+        let entries;
+        try {
+            entries = await fs.readdir(root);
+        }
+        catch (error) {
+            if (error.code === "ENOENT")
+                return [];
+            throw error;
+        }
+        const records = [];
+        for (const entry of entries.filter(value => /^[0-9a-f]{64}\.json$/u.test(value)).slice(0, 4096)) {
+            try {
+                const parsed = JSON.parse(await fs.readFile(path.join(root, entry), "utf8"));
+                const repoId = typeof parsed.repoId === "string" ? normalizeRepoId(parsed.repoId) : "";
+                if (repoId && validRecord(parsed, repoId))
+                    records.push(parsed);
+            }
+            catch (error) {
+                if (!(error instanceof SyntaxError))
+                    throw error;
+            }
+        }
+        return records.sort((left, right) => left.repoId.localeCompare(right.repoId));
+    }
     async observe(repoId, runtimeContract, dispatchAttemptId, verifiedPortNames) {
         if (!hostRuntimeParallelEligible(runtimeContract)) {
             throw new Error("host_parallel_promotion_ineligible: the runtime contract is not eligible for parallel host execution.");
@@ -34,6 +60,7 @@ export class HostParallelPromotionStore {
             schemaVersion: 1,
             repoId: normalizedRepoId,
             runtimeContractFingerprint: hostRuntimeContractFingerprint(runtimeContract),
+            runtimeContractSource: runtimeContract.source === "project" ? "project" : "derived",
             observedAt: new Date().toISOString(),
             observedDispatchAttemptId: normalizedUuid(dispatchAttemptId, "dispatch attempt"),
             verifiedPortNames: observedPorts,
@@ -71,18 +98,22 @@ export function hostRuntimeContractFingerprint(runtimeContract) {
     const canonical = JSON.stringify({
         schemaVersion: runtimeContract.contract.schemaVersion,
         runtime: runtimeContract.contract.runtime,
+        derivedCandidateFingerprint: runtimeContract.source === "derived"
+            ? runtimeContract.discovery?.candidateFingerprint ?? null
+            : null,
     });
     return `sha256:${createHash("sha256").update(canonical).digest("hex")}`;
 }
 export function hostRuntimeParallelEligible(runtimeContract) {
     const runtime = runtimeContract.contract.runtime;
-    return runtimeContract.source === "project"
+    const launchedPorts = runtime.ports.filter(port => port.launch !== null);
+    return (runtimeContract.source === "project" || runtimeContract.source === "derived")
         && runtime.hostConcurrency === "parallel"
         && runtime.browserProfile === "isolated"
         && runtime.singletonResources.length === 0
-        && runtime.ports.length === 1
-        && runtime.ports[0]?.adapter !== null
-        && runtime.ports[0]?.launch !== null;
+        && launchedPorts.length > 0
+        && launchedPorts.length === runtime.ports.length
+        && launchedPorts.every(port => port.adapter !== null);
 }
 export function configuredLaunchPortNames(runtimeContract) {
     return runtimeContract.contract.runtime.ports

package/dist/runtime/node-host-runtime-adapter.d.ts

@@ -15,8 +15,15 @@ export interface NodeRuntimeLaunchRequest extends NodeRuntimeCommand {
 export interface NodeRuntimeCommandLauncher<T> {
     readonly launch: (request: NodeRuntimeLaunchRequest, signal?: AbortSignal) => Promise<T>;
     readonly inspectListener: (value: T, request: NodeRuntimeLaunchRequest, signal?: AbortSignal) => Promise<HostListenerOwnership>;
+    readonly readinessDiagnostics?: (value: T) => Promise<NodeRuntimeReadinessDiagnostics>;
     readonly stop: (value: T) => Promise<void>;
 }
+export interface NodeRuntimeReadinessDiagnostics {
+    readonly exited: boolean;
+    readonly exitCode?: number;
+    readonly stdoutTail?: string;
+    readonly stderrTail?: string;
+}
 export interface NodeHostRuntimeAdapterOptions {
     readonly readinessTimeoutMs?: number;
     readonly readinessPollIntervalMs?: number;

package/dist/runtime/node-host-runtime-adapter.js

@@ -13,7 +13,7 @@ export class NodeHostRuntimeAdapter {
     probeHttp;
     constructor(broker, options = {}) {
         this.broker = broker;
-        this.readinessTimeoutMs = boundedInteger(options.readinessTimeoutMs ?? 30_000, 100, 120_000, "readinessTimeoutMs");
+        this.readinessTimeoutMs = boundedInteger(options.readinessTimeoutMs ?? 120_000, 100, 120_000, "readinessTimeoutMs");
         this.readinessPollIntervalMs = boundedInteger(options.readinessPollIntervalMs ?? 100, 10, 5_000, "readinessPollIntervalMs");
         this.httpProbeTimeoutMs = boundedInteger(options.httpProbeTimeoutMs ?? 1_000, 50, 10_000, "httpProbeTimeoutMs");
         this.probeHttp = options.probeHttp ?? probeHttpReadiness;
@@ -50,10 +50,16 @@ export class NodeHostRuntimeAdapter {
     }
     async waitUntilReady(value, request, launcher, signal) {
         const deadline = Date.now() + this.readinessTimeoutMs;
+        let observedOwnership = "unbound";
         while (Date.now() <= deadline) {
             if (signal?.aborted)
                 throw cancellationError(signal);
+            const diagnostics = await launcher.readinessDiagnostics?.(value);
+            if (diagnostics?.exited) {
+                throw new Error(readinessFailure("host_runtime_process_exited", `the supervised process exited with code ${diagnostics.exitCode ?? "unknown"} before its assigned runtime became ready`, request, diagnostics));
+            }
             const ownership = await launcher.inspectListener(value, request, signal);
+            observedOwnership = ownership;
             if (ownership === "foreign")
                 return false;
             if (ownership === "owned" && await this.probeHttp(request.baseUrl, this.httpProbeTimeoutMs, signal)) {
@@ -61,9 +67,32 @@ export class NodeHostRuntimeAdapter {
             }
             await wait(this.readinessPollIntervalMs, signal);
         }
-        return false;
+        const diagnostics = await launcher.readinessDiagnostics?.(value);
+        if (diagnostics?.exited) {
+            throw new Error(readinessFailure("host_runtime_process_exited", `the supervised process exited with code ${diagnostics.exitCode ?? "unknown"} before its assigned runtime became ready`, request, diagnostics));
+        }
+        const code = observedOwnership === "owned"
+            ? "host_runtime_http_readiness_timeout"
+            : "host_runtime_listener_timeout";
+        const detail = observedOwnership === "owned"
+            ? `the supervised process owned its assigned loopback port but HTTP readiness did not succeed within ${this.readinessTimeoutMs}ms`
+            : `the supervised process did not bind its assigned loopback port within ${this.readinessTimeoutMs}ms`;
+        throw new Error(readinessFailure(code, detail, request, diagnostics));
     }
 }
+function readinessFailure(code, detail, request, diagnostics) {
+    const evidence = [
+        boundedDiagnostic("stderr", diagnostics?.stderrTail),
+        boundedDiagnostic("stdout", diagnostics?.stdoutTail),
+    ].filter((value) => value !== null);
+    return `${code}: ${detail} (${request.baseUrl}).${evidence.length > 0 ? ` ${evidence.join(" ")}` : ""}`;
+}
+function boundedDiagnostic(label, value) {
+    const normalized = value?.replaceAll(/\s+/gu, " ").trim();
+    if (!normalized)
+        return null;
+    return `${label} tail: ${normalized.slice(-2_000)}`;
+}
 export function buildNodeRuntimeLaunchRequest(framework, portConfig, command, port) {
     validateCommand(command);
     if (port.hostIp !== "127.0.0.1" || port.protocol !== "tcp") {
@@ -81,25 +110,56 @@ export function buildNodeRuntimeLaunchRequest(framework, portConfig, command, po
         ? aspNetCoreArguments(command.command, command.args)
         : [...command.args, ...frameworkArguments(framework, port.hostIp, port.hostPort)];
     const adapterEnvironment = framework === "aspnetcore"
-        ? { ASPNETCORE_URLS: baseUrl, DOTNET_NOLOGO: "1" }
+        ? {
+            ASPNETCORE_URLS: baseUrl,
+            Hosting__Port: String(port.hostPort),
+            Harness__Reconciler__Hosted: "false",
+            Projects__RuntimeReadiness__Hosted: "false",
+            Runners__ServerLocalHeartbeat__Hosted: "false",
+            FORGE_RUNTIME_MODE: "host",
+            FORGE_DISPATCH_ATTEMPT_ID: port.dispatchAttemptId,
+            DOTNET_CLI_USE_MSBUILD_SERVER: "0",
+            DOTNET_NOLOGO: "1",
+        }
         : { HOST: port.hostIp };
+    const forgeEnvironment = {
+        FORGE_RUNTIME_PORT_NAME: portConfig.name,
+        FORGE_RUNTIME_PORT: String(port.hostPort),
+        FORGE_RUNTIME_BASE_URL: baseUrl,
+    };
+    const expansionScope = {
+        ...command.environment,
+        ...portEnvironment,
+        ...adapterEnvironment,
+        ...forgeEnvironment,
+    };
     return {
         framework,
         command: command.command,
         args,
         cwd: path.resolve(command.cwd),
         environment: {
-            ...command.environment,
+            ...expandCommandEnvironment(command.environment, expansionScope),
             ...portEnvironment,
             ...adapterEnvironment,
-            FORGE_RUNTIME_PORT_NAME: portConfig.name,
-            FORGE_RUNTIME_PORT: String(port.hostPort),
-            FORGE_RUNTIME_BASE_URL: baseUrl,
+            ...forgeEnvironment,
         },
         port,
         baseUrl,
     };
 }
+function expandCommandEnvironment(environment, scope) {
+    return Object.fromEntries(Object.entries(environment ?? {}).map(([name, value]) => [
+        name,
+        value.replaceAll(/\$\{([A-Za-z_][A-Za-z0-9_]*)\}/gu, (_match, variable) => {
+            const resolved = scope[variable];
+            if (!resolved) {
+                throw new Error(`node_runtime_adapter_invalid: launch environment references unavailable variable '${variable}'.`);
+            }
+            return resolved;
+        }),
+    ]));
+}
 function frameworkArguments(framework, hostIp, hostPort) {
     if (framework === "vite")
         return ["--host", hostIp, "--port", String(hostPort), "--strictPort"];
@@ -139,6 +199,9 @@ function aspNetCoreArguments(command, args) {
     const insertionIndex = applicationArguments < 0 ? args.length : applicationArguments;
     return [
         ...args.slice(0, insertionIndex),
+        "--disable-build-servers",
+        "-p:UseSharedCompilation=false",
+        "-p:DefaultItemExcludesInProjectFolder=TestResults/**",
         "--no-launch-profile",
         ...args.slice(insertionIndex),
     ];
@@ -151,7 +214,7 @@ function validateCommand(command) {
         throw new Error("node_runtime_adapter_invalid: command, arguments, or absolute working directory are invalid.");
     }
     for (const [name, value] of Object.entries(command.environment ?? {})) {
-        if (!/^[A-Z_][A-Z0-9_]{0,127}$/u.test(name) || !boundedText(value, 8192)) {
+        if (!/^[A-Za-z_][A-Za-z0-9_]{0,127}$/u.test(name) || !boundedText(value, 8192)) {
             throw new Error("node_runtime_adapter_invalid: command environment is invalid.");
         }
     }

package/dist/runtime/playwright-host-runtime-adapter.js

@@ -1,4 +1,5 @@
 import fs from "node:fs/promises";
+import os from "node:os";
 import path from "node:path";
 import { pathToFileURL } from "node:url";
 const maximumConfigBytes = 1024 * 1024;
@@ -29,6 +30,8 @@ export class PlaywrightHostRuntimeAdapter {
         }
         const baseUrl = loopbackHttpUrl(context.baseUrl);
         const overlayPath = path.join(temporaryDirectory, "forge.playwright.config.mjs");
+        const browserCache = await resolvePlaywrightBrowserCache(attemptRoot);
+        const browserInstallCommand = await resolvePlaywrightBrowserInstallCommand(context.worktreePath, path.dirname(realSource));
         await fs.writeFile(overlayPath, renderOverlay({
             projectConfigUrl: pathToFileURL(realSource).href,
             projectConfigDirectory: path.dirname(realSource),
@@ -41,6 +44,10 @@ export class PlaywrightHostRuntimeAdapter {
             environment: {
                 FORGE_PLAYWRIGHT_CONFIG: overlayPath,
                 FORGE_PLAYWRIGHT_BASE_URL: baseUrl,
+                FORGE_E2E_WEB_URL: baseUrl,
+                FORGE_PLAYWRIGHT_BROWSER_READY: browserCache.ready ? "true" : "false",
+                FORGE_PLAYWRIGHT_BROWSER_INSTALL_COMMAND: browserInstallCommand,
+                PLAYWRIGHT_BROWSERS_PATH: browserCache.path,
                 PLAYWRIGHT_HTML_OUTPUT_DIR: path.join(testOutputDirectory, "html-report"),
                 PLAYWRIGHT_BLOB_OUTPUT_DIR: path.join(testOutputDirectory, "blob-report"),
                 PLAYWRIGHT_JUNIT_OUTPUT_NAME: path.join(testOutputDirectory, "results.xml"),
@@ -51,6 +58,71 @@ export class PlaywrightHostRuntimeAdapter {
         };
     }
 }
+async function resolvePlaywrightBrowserInstallCommand(worktreePath, configDirectory) {
+    const relativeDirectory = path.relative(worktreePath, configDirectory).replaceAll(path.sep, "/") || ".";
+    if (await isFile(path.join(configDirectory, "pnpm-lock.yaml"))) {
+        return `pnpm --dir ${quoteCommandArgument(relativeDirectory)} exec playwright install chromium`;
+    }
+    if (await isFile(path.join(configDirectory, "yarn.lock"))) {
+        return `yarn --cwd ${quoteCommandArgument(relativeDirectory)} playwright install chromium`;
+    }
+    return `npm --prefix ${quoteCommandArgument(relativeDirectory)} exec playwright install chromium`;
+}
+async function isFile(candidate) {
+    try {
+        return (await fs.stat(candidate)).isFile();
+    }
+    catch {
+        return false;
+    }
+}
+function quoteCommandArgument(value) {
+    return /[\s"']/u.test(value) ? JSON.stringify(value) : value;
+}
+async function resolvePlaywrightBrowserCache(attemptRoot) {
+    const candidates = [
+        process.env.PLAYWRIGHT_BROWSERS_PATH,
+        process.env.LOCALAPPDATA ? path.join(process.env.LOCALAPPDATA, "ms-playwright") : null,
+        path.join(os.homedir(), ".cache", "ms-playwright"),
+    ].filter((candidate) => Boolean(candidate?.trim()));
+    for (const candidate of [...new Set(candidates.map(candidate => path.resolve(candidate)))]) {
+        if (await hasChromiumExecutable(candidate)) {
+            return { path: candidate, ready: true };
+        }
+    }
+    const attemptCache = path.join(attemptRoot, "cache", "ms-playwright");
+    await fs.mkdir(attemptCache, { recursive: true });
+    return { path: attemptCache, ready: false };
+}
+async function hasChromiumExecutable(cachePath) {
+    let entries;
+    try {
+        entries = await fs.readdir(cachePath, { withFileTypes: true });
+    }
+    catch {
+        return false;
+    }
+    const executableSuffixes = process.platform === "win32"
+        ? [path.join("chrome-win64", "chrome.exe"), path.join("chrome-win", "chrome.exe")]
+        : process.platform === "darwin"
+            ? [path.join("chrome-mac", "Chromium.app", "Contents", "MacOS", "Chromium")]
+            : [path.join("chrome-linux", "chrome"), path.join("chrome-linux64", "chrome")];
+    for (const entry of entries) {
+        if (!entry.isDirectory() || !entry.name.startsWith("chromium-"))
+            continue;
+        for (const suffix of executableSuffixes) {
+            try {
+                const stat = await fs.stat(path.join(cachePath, entry.name, suffix));
+                if (stat.isFile())
+                    return true;
+            }
+            catch {
+                // Continue through known Playwright layouts.
+            }
+        }
+    }
+    return false;
+}
 function renderOverlay(values) {
     return [
         "// Generated by forge-bridge for one fenced host attempt.",
@@ -82,6 +154,17 @@ function renderOverlay(values) {
         "      ? [resolveModulePath(reporter[0]), ...reporter.slice(1)]",
         "      : resolveModulePath(reporter))",
         "  : resolveModulePath(projectConfig.reporter);",
+        "const forgeProviderOnlySpecs = (() => {",
+        "  try {",
+        "    const parsed = JSON.parse(process.env.FORGE_CI_REPAIR_PROVIDER_ONLY_SPECS ?? '[]');",
+        "    return Array.isArray(parsed) ? parsed.filter(value => typeof value === 'string' && value.length > 0) : [];",
+        "  } catch {",
+        "    return [];",
+        "  }",
+        "})();",
+        "const forgeTestIgnore = forgeProviderOnlySpecs.length === 0",
+        "  ? projectConfig.testIgnore",
+        "  : [...(Array.isArray(projectConfig.testIgnore) ? projectConfig.testIgnore : projectConfig.testIgnore ? [projectConfig.testIgnore] : []), ...forgeProviderOnlySpecs];",
         "export default {",
         "  ...projectConfig,",
         "  testDir: resolveConfigPath(projectConfig.testDir),",
@@ -89,6 +172,7 @@ function renderOverlay(values) {
         "  globalSetup: resolveModulePath(projectConfig.globalSetup),",
         "  globalTeardown: resolveModulePath(projectConfig.globalTeardown),",
         "  reporter: forgeReporter,",
+        "  testIgnore: forgeTestIgnore,",
         `  outputDir: ${JSON.stringify(values.testOutputDirectory)},`,
         `  workers: ${values.workers},`,
         "  webServer: undefined,",

package/dist/sandbox/preflight.d.ts

@@ -39,7 +39,16 @@ export declare function evaluateDiskPressure(availableBytes: number, totalBytes:
 export declare function storagePolicyAvailable(storageQuota: boolean, environment?: NodeJS.ProcessEnv): boolean;
 export declare class DockerContextOwnershipLock {
     private lockPath;
+    private lockToken;
     acquire(contextName?: string): Promise<void>;
     release(): Promise<void>;
 }
 export declare function parseDockerMemoryUsage(value: string): number;
+interface DockerContextLockOwner {
+    readonly token?: string;
+    readonly pid?: number;
+    readonly processIdentity?: string | null;
+    readonly acquiredAt?: string;
+}
+export declare function dockerContextOwnerIsActive(owner: DockerContextLockOwner | null): boolean;
+export {};

package/dist/sandbox/preflight.js

@@ -1,7 +1,8 @@
 import fs from "node:fs/promises";
 import os from "node:os";
 import path from "node:path";
-import { createHash } from "node:crypto";
+import { createHash, randomUUID } from "node:crypto";
+import { captureHostProcessIdentity } from "../shared/process/host-process-supervisor.js";
 import { BoundedCommandRunner } from "./command-runner.js";
 const minimumWorkspaceBytes = 10 * 1024 * 1024 * 1024;
 const defaultHostMemoryReserveBytes = 2 * 1024 ** 3;
@@ -189,34 +190,48 @@ export function storagePolicyAvailable(storageQuota, environment = process.env)
 }
 export class DockerContextOwnershipLock {
     lockPath = null;
+    lockToken = null;
     async acquire(contextName) {
         if (this.lockPath)
             return;
         contextName = contextName?.trim() || process.env.DOCKER_CONTEXT?.trim() || process.env.DOCKER_HOST?.trim() || "default";
         const key = createHash("sha256").update(contextName).digest("hex").slice(0, 24);
         const lockPath = path.join(os.tmpdir(), `forge-docker-context-${key}.lock`);
+        const token = randomUUID();
         await fs.mkdir(path.dirname(lockPath), { recursive: true });
         try {
             const handle = await fs.open(lockPath, "wx", 0o600);
-            await handle.writeFile(JSON.stringify({ pid: process.pid, contextName, acquiredAt: new Date().toISOString() }));
+            await handle.writeFile(JSON.stringify({
+                schemaVersion: 2,
+                token,
+                pid: process.pid,
+                processIdentity: captureHostProcessIdentity(process.pid),
+                contextName,
+                acquiredAt: new Date().toISOString(),
+            }));
             await handle.sync();
             await handle.close();
         }
         catch (error) {
             const owner = await readLock(lockPath);
-            if (owner?.pid && !processExists(owner.pid)) {
+            if (!dockerContextOwnerIsActive(owner)) {
                 await fs.rm(lockPath, { force: true });
                 return await this.acquire(contextName);
             }
             throw new Error(`docker_context_owned: Docker context '${contextName}' is already owned by Forge runner pid ${owner?.pid ?? "unknown"}.`, { cause: error });
         }
         this.lockPath = lockPath;
+        this.lockToken = token;
     }
     async release() {
         if (!this.lockPath)
             return;
-        await fs.rm(this.lockPath, { force: true });
+        const owner = await readLock(this.lockPath);
+        if (owner?.token === this.lockToken) {
+            await fs.rm(this.lockPath, { force: true });
+        }
         this.lockPath = null;
+        this.lockToken = null;
     }
 }
 function parseInfo(stdout) {
@@ -289,6 +304,26 @@ export function parseDockerMemoryUsage(value) {
 async function readLock(lockPath) {
     return await fs.readFile(lockPath, "utf8").then((value) => JSON.parse(value)).catch(() => null);
 }
+export function dockerContextOwnerIsActive(owner) {
+    if (!owner || !Number.isSafeInteger(owner.pid) || (owner.pid ?? 0) <= 0 || !processExists(owner.pid)) {
+        return false;
+    }
+    const liveIdentity = captureHostProcessIdentity(owner.pid);
+    if (owner.processIdentity) {
+        // A live but unverifiable process must remain protected. Windows and Linux
+        // normally provide a birth marker, so a mismatch is positive PID-reuse proof.
+        return !liveIdentity || liveIdentity === owner.processIdentity;
+    }
+    if (process.platform === "win32" && liveIdentity?.startsWith("win32:") && owner.acquiredAt) {
+        const ticks = Number(liveIdentity.slice("win32:".length));
+        const acquiredAt = Date.parse(owner.acquiredAt);
+        const processStartedAt = ticks / 10_000 - 62_135_596_800_000;
+        if (Number.isFinite(processStartedAt) && Number.isFinite(acquiredAt) && processStartedAt > acquiredAt) {
+            return false;
+        }
+    }
+    return true;
+}
 function processExists(pid) {
     try {
         process.kill(pid, 0);

package/dist/sandbox/workspace.service.js

@@ -38,8 +38,13 @@ export class SandboxWorkspaceService {
         await this.git.run(this.workspace, ["config", "core.hooksPath", "/dev/null"]);
         await clearRunArtifactRoots(this.workspace, request);
         const artifacts = filterArtifactsForLane(request.artifacts, request.lane, request.phase);
-        if (artifacts.length > 0)
-            await injectWorktreeArtifacts(this.workspace, artifacts);
+        if (artifacts.length > 0) {
+            const trackedForgePaths = new Set((await this.git.run(this.workspace, ["ls-files", "-z", "--", ".forge"]))
+                .split("\0")
+                .filter(Boolean)
+                .map(value => value.replaceAll("\\", "/")));
+            await injectWorktreeArtifacts(this.workspace, artifacts, trackedForgePaths);
+        }
         const hydratedPriorPhaseArtifactCount = await hydratePriorPhaseArtifacts(this.workspace, request.priorPhaseArtifacts);
         return {
             repoPath: this.workspace,

package/dist/session/managed-attempt-tools.d.ts

@@ -0,0 +1,17 @@
+export declare const managedAttemptToolNames: readonly ["forge.run_managed_command", "run_managed_command", "forge.start_managed_command", "start_managed_command", "forge.get_managed_command", "get_managed_command", "forge.wait_managed_command", "wait_managed_command", "forge.start_managed_verification", "start_managed_verification", "forge.reset_generated_outputs", "reset_generated_outputs"];
+export declare function isManagedAttemptTool(name: string): boolean;
+export declare function managedAttemptToolDefinition(name: string): unknown;
+export interface ManagedAttemptToolResult {
+    readonly content: readonly {
+        readonly type: "text";
+        readonly text: string;
+    }[];
+    readonly structuredContent: Readonly<Record<string, unknown>>;
+    readonly isError?: boolean;
+}
+export declare function callManagedAttemptTool(name: string, input: unknown, worktreePath: string): Promise<ManagedAttemptToolResult>;
+export declare function buildManagedVerificationCommand(profile: string, outputDirectory: string, shardCount: number, shardIndex: number, noBuild: boolean): {
+    command: string;
+    args: readonly string[];
+    timeoutMs: number;
+};